; BASIC 16K 
; NUOVA ELETTRONICA
;	 v. 20220717



#TARGET BIN


;
; BASIC 16K 
; NUOVA ELETTRONICA
;



#CODE BASIC16, 0x0000
			;
			; Costanti e definizioni variabili
			; BASIC 16K 
			; NUOVA ELETTRONICA
			;
CHCC		EQU		0x03					; Carattere <CTRLC>
CHBS		EQU		0x08					; Carattere <BS>
CHTB		EQU		0x09					; Carattere <TAB>
CHLF		EQU		0x0A					; Carattere <LF>
CHFF		EQU		0x0C					; Carattere <FF>
CHCR		EQU		0x0D					; Carattere <CR>
CHPN		EQU		0x0E					; Carattere <PGN>
CHCO		EQU		0x0F					; Carattere <CTRLO>
CHCS		EQU		0x13					; Carattere <CTRLS>
CHCX		EQU		0x18					; Carattere <CTRLX>
CHHM		EQU		0x1C					; Carattere <HOME>
CHEL		EQU		0x1E					; Carattere <EOL>
CHES		EQU		0x1F					; Carattere <EOS>
											;
PORT_PRINT	EQU		0x03					; Porta stampante
PORT_KBDIN	EQU		0xEA					; Porta dati tastiera 
PORT_VSYNC	EQU		0xEB					; Porta segnale sincronismo verticale video, attivo b7=0
PORT_TAPEI	EQU		0xEE					; Porta dati tape input
PORT_TAPED	EQU		0xEF					; Porta dati tape output
											;
VIDBASE		EQU		0xEC00					; Indirizzo base memoria video
VHIGH		EQU		HI(VIDBASE+16*0x20)		; Parte alta indirizzo memoria video oltre ultima riga
											;
NMI			EQU		0x0066					; Entry point NMI
											;
VCKCHAR		EQU		0x08					; RST 0x08
VGETCH		EQU		0x10					; RST 0x10
VCPDEHL		EQU		0x18					; RST 0x18
VGETTYPE	EQU		0x20					; RST 0x20
VVECSYS		EQU		0x28					; RST 0x28
											;
FLAGFOR		EQU		0x64					; Flag istruzione FOR
MAXLENBUF	EQU		0xF0					; Massima lunghezza buffer (240)
											;
ECOD00		EQU		0x00					; NEXT WITHOUT FOR
ECOD02		EQU		0x02					; SYNTAX ERROR
ECOD04		EQU		0x04					; RETURN WITHOUT GOSUB
ECOD06		EQU		0x06					; OUT OF DATA
ECOD08		EQU		0x08					; ILLEGAL FUNCTION CALL
ECOD0A		EQU		0x0A					; OVERFLOW		
ECOD0C		EQU		0x0C					; OUT OF MEMORY
ECOD0E		EQU		0x0E					; UNDEFINED LINE NUMBER
ECOD10		EQU		0x10					; SUBSCRIPT OUT OF RANGE
ECOD12		EQU		0x12					; REDIMENSIONED ARRAY
ECOD14		EQU		0x14					; DIVISION BY ZERO
ECOD16		EQU		0x16					; ILLEGAL DIRECT
ECOD18		EQU		0x18					; TYPE MISMATCH
ECOD1A		EQU		0x1A					; OUT OF STRING SPACE
ECOD1C		EQU		0x1C					; STRING TOO LONG
ECOD1E		EQU		0x1E					; STRING FORMULA TOO COMPLEX
ECOD20		EQU		0x20					; CAN'CONTINUE
ECOD22		EQU		0x22					; NO RESUME
ECOD24		EQU		0x24					; RESUME WITHOUT ERROR
ECOD26		EQU		0x26					; UNPRINTABLE ERROR
ECOD28		EQU		0x28					; MISSING OPERAND
ECOD2A		EQU		0x2A					; BAD FILE DATA
ECOD2C		EQU		0x02					; SYNTAX ERROR
											;												
VARINIT		EQU		L4000					; Inzio zona variabili di sistema
											;
											; /Inizio area copiata
L4000		EQU		0x4000					;	C3961C	JP CKCHAR	(Vettore 0x4000 per RST 0x08)
L4003		EQU		0x4003					;	C3781D	JP GETCH	(Vettore 0x4003 per RST 0x10) 
L4006		EQU		0x4006					;	C3901C	JP CPDEHL	(Vettore 0x4006 per RST 0x18)
L4009		EQU		0x4009					;	C3D925	JP GETTYPE	(Vettore 0x4009 per RST 0x20)
L400C		EQU		0x400C					;	C9		RET			(Vettore 0x400C per RST 0x28)	C3 JP xxxx
											;   00		NOP											xx
											;	00		NOP											xx
L400F		EQU		0x400F					;	C9		RET			(vettore 0x400F per RST 0x30)
											;   00		NOP
											;	00		NOP
L4012		EQU		0x4012					;	FB		EI			(vettore 0x4012 per RST 0x38)
											;   C9		RET
											;	00		NOP
											;
TBVEC01		EQU		0x4015					;	01		Tabella funzioni 
TBVEC01F1	EQU		0x4016					;	E3 03	Punto salto indiretto per EXEC01 => L03E3 INHWKB
TBVEC07		EQU		0x401D					;	07		Tabella funzioni 
TBVEC07F1	EQU		0x401E					;   F5 03	Punto salto indiretto per EXEC02 => L03F5 IOSCR
											;
SCRCURR		EQU		0x4020					;	00 EC	Indirizzo corrente memoria video
											;
TBVEC06		EQU		0x4025					;	06		Tabella funzioni 
TBVEC06F1	EQU		0x4026					;   9F 04	Punto salto indiretto per EXEC01 => L049F PRCHAR
											;
VARLF		EQU		0x4028					; Flag Linefeed automatico	00=NO, 01=YES
											;
ZEROA		EQU		0x4033					;	3E00	LD A,0x00	Azzera A
											;	C9		RET			Termina
											; /Fine area copiata
											;
											; /Inizio area azzerata
UNK09		EQU		0x4036					; UNK08
											;			
CHNNO		EQU		0x403D  				; Canale in output - 0x08=Tape 0x10=Video
			;		0x405C					; /Fine area azzerata
											;
											; /Inizio area copiata
DIVSUP		EQU		0x4080					;	D600	SUB 0x00	Sottrae da A il valore DIV1	(0x4081)	
DIV1		EQU		0x4081					;	6F		LD L,A		Copia A in L						
											;	7C		LD A,H		Copia H in A						
DIV2		EQU		0x4085					;	DE00	SBC A,0x00	Sottrae da A il valore DIV2 (0x4085) e il CY	
											;	67		LD H,A		Copia A in H
											;	78		LD A,B		Copia B in A
DIV3		EQU		0x4089					;	DE00	SBC A,0x00	Sottrae da A il valore DIV3 (0x4089) e il CY
											;	47		LD B,A		Copia A in B
DIV4		EQU		0x408C					;	3E00	LD A,0x00	Carica in A il valore DIV4 (0x408C)	
											;	C9		RET     	Ritorna (408D)
											;
GENINP		EQU		0x4093					;	IN A,(0x00)			Input in A da porta xx, modificata alla locazione 0x4094
											;	RET					Ritorna (4095)						
											;
GENOUT		EQU		0x4096					;	OUT (0x00),A		Out di A su porta xx, modificata alla locazione 0x4097
											;	RET					Ritorna (4098)						
											;
LSTKEY		EQU		0x4099					; Ultimo tasto premuto 0x00=Nessun tasto
CURERR		EQU		0x409A					; Codice errore corrente
CPOSPRN		EQU		0x409B					; Posizione corrente stampante
DEVOUT		EQU		0x409C					; Device carattere in uscita, 0x00=video 0x01=stampente, 0x80=tape
PLEN		EQU		0x409D					; Lunghezza 
COMMAW		EQU		0x409E					; Lunghezza area per virgola
STRSPC		EQU		0x40A0					; Limite superiore area stringhe
LINEAT		EQU		0x40A2					; Numero linea corrente 
BASTXT		EQU		0x40A4					; Puntatore all'inizio testo BASIC
CURPOS		EQU		0x40A6					; Posizione corrente cursore
											; /Fine area Copiata
											;
PBUFFER		EQU		0x40A7					; Puntatore a BUFFER testo BASIC corrente
UNK01		EQU		0x40AA					; UNK01
RNDVAL		EQU		0x40AB					; Valore random
UNK02		EQU		0x40AC					; UNK02
LCRFLG		EQU		0x40AE					; Flag LOCATE/CREATE per gestione variabili 0x00=LOCATE
TYPE		EQU		0x40AF					; Tipo dato 0x00=Nessuno 0x02=Intero 0x03=Stringa 0x04=Single 0x08=Double
DATFLG		EQU		0X40B0					; Tipo dato 0x00=Nessuno 0x01=Literal
EOFRAM		EQU		0x40B1					; Limite superiore della RAM
TMSTPT		EQU		0x40B3					; Puntatore all'area delle stringhe temporanee
TSAREA		EQU		0x40B5					; Inizio area stringhe temporanee
TMPSTR		EQU		0x40D3					; Puntatore a descrittore stringa temporanea
TSLEN		EQU		TMPSTR					; Lunghezza stringa temporanea
TSADD		EQU		TMPSTR+1				; Indirizzo stringa temporanea
STRBOT		EQU		0x40D6					; Limite inferiore area stringhe
CUROPR		EQU		0x40D8					; Token operatore corrente 
DATLIN		EQU		0x40DA					; Numero linea del campo DATA corrente
FORFLG		EQU		0x40DC					; Flag FOR  0x00=Nullo  0x64=FOR  0x80=FN
LSTBIN		EQU		0x40DD					; ?(Last byte entered)
READFG		EQU		0x40DE					; Flag per 0x00=INPUT altrementi READ
PCODE2RUN	EQU		0x40DF					; puntatore a codice corrente 
AUTOACT		EQU		0x40E1					; AUTO attivo 0=NO altrimenti SI
AUTONXTL	EQU		0x40E2					; AUTO prossimo numero di linea
AUTOSTEP	EQU		0x40E4					; Passo della AUTO
UNK03		EQU		0x40E6					; UNK03
SPTMP		EQU		0x40E8					; Valore temporaneo di SP
CURERL		EQU		0x40EA					; Valore ERL corrente
CUREDLN		EQU		0x40EC					; Numero linea corrente per EDIT
UNK04		EQU		0x40EE					; UNK04
ONERLN		EQU		0x40F0					; Linea corrente per la ON ERROR
RESACT		EQU		0x40F2					; Linea corrente per la RESUME
NXTOPR		EQU		0x40F3					; Indirizzo prossimo operatore
											;
PRGEND		EQU		0x40F9					; Fine area testo programma  
VAREND		EQU		0x40FB					; Fine area variabili
ARREND		EQU		0x40FD					; Fine area array
NXTDAT		EQU		0x40FF					; Prossima istruzione DATA
DEFTVAR		EQU		0x4101					; Tipo variabili che iniziano con A
			;		0x411A					  fino a 0x411A  TYPEZ
TRCVAL		EQU		0x411B					; Flag per TRACE 0x00=OFF altrimenti ON
TDBL1		EQU		0x411D					; Double temporaneo prima parte
TDBL2		EQU		0x411F					; Double temporaneo seconda parte
FPREG		EQU		0x4121					; Registro FP (FPREG)
FPREGMSB	EQU		0x4123					; MSB di FPREG
FPEXP		EQU		0x4124					; Esponente FPREG
UNK05		EQU		0x4127					; UNK05
UNK06		EQU		0x412D					; UNK06
											;
CONVBUFF	EQU		0x4130					; Buffer conversione da numero ad ASCII
											;
MULMSB		EQU		0x414F					; MSB del moltiplicatore
MULLSB		EQU		0x4150					; LSB del moltiplicatore
L4152		EQU		0x4152					; .DW IFERR
L4154		EQU		0x4154					; .DW IFERR
L4156		EQU		0x4156					; .DW IFERR
L4158		EQU		0x4158					; .DW IFERR
L415A		EQU		0x415A					; .DW IFERR
L415C		EQU		0x415C					; .DW IFERR
L415E		EQU		0x415E					; .DW IFERR
L4160		EQU		0x4160					; .DW IFERR
L4162		EQU		0x4162					; .DW IFERR
L4164		EQU		0x4164					; .DW IFERR
SZIFERR		EQU		1+(L4164-L4152)/2		;
											;
											; --- (Inizio 34 locazioni per SYSTEM) 
PRNSTAT		EQU		0x4166					; Stato stampante per hardcopy 0=NO 1=YES	
SPINI		EQU		0x4167					; Valore iniziale SP
TMSPSYS		EQU		0x416F					; Valore di SP prima di SYSTEM
TMPRAD		EQU		0x4171					; Temporaneo per indirizzo di rientro
UNK07		EQU		0x417D					; UNK07
SPTMP2		EQU		0x417F					; Temporaneo per valore SP
IXTMP		EQU		0x4181					; Temporaneo per valore IX
CONST00A	EQU		0x4183					; Valore costante 0x00
CONST00HL	EQU		0x4184					; Valore costante 0x0000
CONST00A2	EQU		0x4186					; Valore costante 0x00
ATMP		EQU		0x4187					; Temporaneo per valore A
											; --- (Fine 34 locazioni per SYSTEM) 
											;
PREBUFFER	EQU		0x41E5					; Area testo precedente il BUFFER
BUFFER		EQU		0x41E8					; Inizio BUFFER testo codice utente;
											; 0x42D8 - Fine BUFFER massima lunghezza 0xF0
											;
											;
USRBASCOD	EQU		BUFFER+0x0100			; Inizio codice utente BASIC 0x42E8
BEGRAM		EQU		0x434C					; Inizio RAM da testare 
											;
UNK10		EQU		0x4414					; UNK10

ROMF000		EQU		0XF000					; Indirizzo per BOOT
											;
											; TOKEN
											;
FIRSTTK		EQU		TKEND					; Primo token
TKEND		EQU		0x80					; Token END
TKFOR		EQU		0x81					; Token FOR
TKNEXT		EQU		0x87					; Token NEXT
TKDATA		EQU		0x88					; Token DATA
TKINPUT		EQU		0x89					; Token INPUT
TKPRINT		EQU		0xB2					; Token PRINT e ?
TKGOTO		EQU		0x8D					; Token GOTO
TKGOSUB		EQU		0x91					; Token GOSUB
TKREM		EQU		0x93					; Token REM
TKELSE		EQU		0x95					; Token ELSE
TKERROR		EQU		0x9E					; Token ERROR
TKSPC		EQU		0xBC					; Token SPC
TKTO		EQU		0xBD					; Token TO
TKFN		EQU		0xBE					; Token FN
TKTAB		EQU		0xBF					; Token TAB
TKUSR		EQU		0xC1					; Token USR
TKERR		EQU		0xC3					; Token ERR
TKSTRING	EQU		0xC4					; Token STRING$
TKINSTR		EQU		0xC5					; Token INSTR
TKPOINT		EQU		0xC6					; Token POINT
TKTIME		EQU		0xC7					; Token TIME$
TKMEM		EQU		0xC8					; Token MEM
TKINKEY		EQU		0xC9					; Token INKEY$
TKTHEN		EQU		0xCA					; Token THEN
TKNOT		EQU		0xCB					; Token NOT
TKSTEP		EQU		0xCC					; Token STEP
TKPLUS		EQU		0xCD					; Token +
TKMINUS		EQU		0xCE					; Token -
TKGT		EQU		0xD4					; Token >
TKEQUAL		EQU		0xD5					; Token =


			;
			; Codice 
			; BASIC 16K 
			; NUOVA ELETTRONICA
			;
			;
			; 
			; 0x0000 - HWRESET  MAIN START AT RESET
			;
HWRESET		DI      					; Disabilita interrupt
			XOR  A						; Azzera A
			JP BASIC					; Passa a 0x0674 (L0674 BASIC)

			;
			; Routine 0x0005 - VCKCHAR5  RST 0x08  Controlla sintassi carattere corrente
			;
VCKCHAR5	JP L4000					; Passa alla 0x4000 (L4000 CKCHAR)

			;
			; Routine 0x0008 - VCKCHAR  RST 0x08  Controlla sintassi carattere corrente
			;
VCKCHAR		JP L4000					; Passa alla 0x4000 (L4000 CKCHAR)

			;
			; Routine 0x000B - VINDJP  Elimina inDIRizzo ritorno dallo stack ed esegue salto corrispondente
			;
VINDJP		POP HL						; Recupera HL dallo stack
			JP (HL)						; Passa a inDIRizzo puntato da (HL)

			;
			; Routine 0x000D (Punta a codice NOP, ritorna al BASIC, inutilizzato)
			;
L000D		JP L069F					; Passa alla 0x069F (L069F)

			;
			; Routine 0x0010 - VGETCH  RST 0x10  Ottiene prossimo carattere da buffer
			;
VGETCH		JP L4003					; Passa alla 0x4003 (L4003 GETCH)

			;
			; Routine 0x0013 - EXEC01  Esegue vettore da tabella DE con parametro B=0x01
			;
EXEC01		PUSH BC						; Salva BC nello stack
			LD B,0x01					; Carica in B il valore 0x01 
			JR VSVCIO					; Passa alla 0x0046 (L0046 VSVCIO)
			
			;
			; Routine 0x0018 - VCPDEHL  RST 0x18  Compara DE ed HL
			;
VCPDEHL		JP L4006					; Passa alla 0x4006 (L4006 CPDEHL)

			;
			; Routine 0x001B - EXEC02  Esegue vettore da tabella DE con parametro B=0x02
			;
EXEC02		PUSH BC						; Salva BC nello stack
			LD B,0x02					; Carica in B il valore 0x02
			JR VSVCIO					; Passa alla 0x0046 (L0046 VSVCIO)

			;
			; Routine 0x0020 - VGETTYPE  RST 0x20
			;
VGETTYPE	JP L4009					; Passa alla 0x4009 (L4009 GETTYPE)

			;
			; Routine 0x0023 - EXEC04  Esegue vettore da tabella DE con parametro B=0x04
			; (non utilizzata)
EXEC04		PUSH BC						; Salva BC nello stack
			LD B,0x04					; Carica in B il valore 0x04
			JR VSVCIO					; Passa a 0x0046 (L0046 VSVCIO)
			
			;
			; Routine 0x0028 - VVECSYS  RST 0x28 
			;
VVECSYS		JP L400C					; Passa alla 0x400C (L400C VECSYS)

			;
			; Routine 0x002B - GETKHW  Ottiene codice carattere da hardware tastiera in A, oppure 0x00
			;
GETKHW		LD DE,TBVEC01				; Carica in DE il valore 0x4015 (TBVEC01)
			JR EXEC01					; Passa alla 0x0013 (L0013 EXEC01)
			
			;
			; Routine 0x0030 - RST 0x30 (Nessuna operazione)
			;
L0030		JP L400F					; Passa alla 0x400F (L400F ONLYRT2)

			;
			; Routine 0x0033 - HIOSCR  Gestisce I/O video
			;
HIOSCR		LD DE,TBVEC07				; Carica in DE il valore 0x401D (TBVEC07)
			JR EXEC02					; Passa alla 0x001B (L001B EXEC02)

			;
			; Routine 0x0038 - RST 0x38  Abilita Interrupt
			;
L0038		JP L4012					; Passa a 0x4012 (L4012 EIRET)
			
			;
			; Routine 0x003B - HPRCHAR  Gestisce invio carattere su stampante
			;			
HPRCHAR		LD DE,TBVEC06				; Carica in DE il valore 0x4025 (puntatore a tabella vettori TBVEC06)
			JR EXEC02					; Passa alla 0x001B (L001B EXEC02)
			
			;
			; Routine 0x0040 (Inutilizzata)
			;						
L0040		JP KYPARSE					; Passa alla 0x05D9 (L05D9 KYPARSE)

			;
			; (Non utilizzati)			
			;
			RET				
			NOP     
			NOP     

			;
			; Routine 0x0046 - VSVCIO Vettore Salto indiretto a servizio IO
			;
VSVCIO		JP SVCIO					; Passa alla 0x03C2 (L03C2 SVCIO)

			;
			; Routine 0x0049 - WTKEYA  Attende tasto in A
			;
WTKEYA		CALL GETKHW					; Chiama la 0x002B (L002B GETKHW)
			OR A						; Esegue OR A
			RET NZ						; Se diverso da zero, ritorna
			JR WTKEYA					; Altrimenti passa a 0x0049 (L0049 WTKEYA)
			
			; NOP da 0x0050 a 0x005F
			;
			DEFS 0x10, 0x00

			;
			; Routine 0x0060 - DELAYBC  Ritardo, valore iniziale in BC
			;
DELAYBC		DEC BC						; DECrementa BC
			LD A,B						; Copia B in A
			OR C						; Esegue OR di A con C
			JR NZ,DELAYBC				; Se diverso da zero, passa a 0x0060 (L0060 DELAYBC)
			RET							; Ritorna

			;
			; Vettore NMI
			;
NMI			LD SP,0x0600				; Carica in SP il valore 0x0600 (bug, in ROM)

			; NOP da 0x0069 a 0x0071
			;
			DEFS 0x09, 0x00				; NOP da 0x0069 a 0x0071
			JP HDLNMI					; Passa alla 0x06CC (L06CC HDLNMI)

			;
			; 0x0075 - BASIC2 - Continua inizializzazione BASIC
			;
BASIC2		LD DE,DIVSUP				; Carica in DE il puntatore a 0x4080 (DIVSUP)
			LD HL,DIVSUPROM				; Carica in HL il puntatore a 0x18F7 (DIVSUPROM)
			LD BC,0x0027				; Carica in BC il valore 0x0027
			LDIR    					; Copia 0x0027 byte da 0x18F7 in 0x4080
			;
			LD HL,PREBUFFER				; Carica in HL puntatore a 0x41E5 (puntatore a PREBUFFER)
			LD (HL),':'					; Salva 0x3A (carattere ':') in (HL)
			INC HL						; Incrementa HL
			LD (HL),B					; Salva B (0x00) in (HL)
			INC HL						; Incrementa HL
			LD (HL),','					; Salva 0x2C (carattere ',') in (HL)
			INC HL						; Incrementa HL
			LD (PBUFFER),HL				; Salva HL in (0x40A7) PBUFFER (valore 0x41E8 => PREBUFFER+3 => BUFFER)
			;
			LD HL,L4152					; Carica in HL il valore 0x4152
			.BYTE 0x11					; LD DE,0x4A1E  Carica in DE il valore 0x4A1E
			.BYTE HI(IFERR)				;
			.BYTE LO(IFERR)				;
			
			LD B,SZIFERR				; Carica in B il valore 0x0A
L0096		LD (HL),D					; Salva D in (HL)
			INC HL						; Incrementa HL
			LD (HL),E					; Salva E in (HL)
			INC HL						; Incrementa HL
			DJNZ L0096					; Decrementa B, se diverso da zero passa a 0x0096
			;
			DEFS 0x0C, 0x00				; NOP da 0x009C a 0x00A7
			;
			LD HL,USRBASCOD				; Carica in HL puntatore a 0x42E8 (puntatore a USRBASCOD)
			LD (HL),B					; Azzera memoria puntata da (HL)
			LD SP,BUFFER+0x10			; Carica in SP il valore 0x41F8 (Stack Pointer iniziale)
			;
			CALL CLREG					; Chiama la 0x1B8F (L1B8F CLREG)
			CALL CLS					; Chiama la 0x01C9 (L01C9 CLS)
L00B5		LD HL,MMEMSIZ				; Carica in HL il valore 0x0105 (messaggio 'MEMORY SIZE')
			CALL PRS					; Chiama la 0x28A7 (L28A7 PRS)
			CALL VISPPIN				; Chiama la 0x1BB3 (L1BB3 VISPPIN)
			JR C,L00B5					; Se CY=1, passa a 0x00B5 (L00B5) e ripete
 			RST VGETCH					; Chiama la RST 0x10 (L0010 VGETCH)
			OR A						; Esegue OR di A
			JR NZ,ASKMEM				; Se diverso da zero, passa a 0x00E9 (L00E9 ASKMEM)
			;
			; Controllo intera memoria
			;
			LD HL,BEGRAM				; Carica in HL il valore 0x434C (puntatore a BEGRAM), inizio memoria da testare
L00C7		INC HL						; Incrementa HL
			LD A,H						; Copia H in A		
			OR L						; Esegue OR con L, se HL è zero
			JR Z,SETRAM					; Se zero, passa a 0x00FA (L00FA SETRAM) 
			LD A,(HL)					; Carica in A valore da memoria puntata da (HL)
			LD B,A						; Copia A in B
			CPL     					; Inverte A
			LD (HL),A					; Salva A in memoria puntata da (HL)
			CP (HL)						; Compara A con memoria puntata da (HL)
			LD (HL),B					; Salva B in memoria puntata da (HL)
			JR Z,L00C7					; Se uguale, passa a 0x00C7, prossima locazione
			JR SETRAM					; Altrimenti, incontrata ROM, passa a 0x00FA (L00FA SETRAM)

ASKMEM		CALL ATOH					; Chiama la 0x1E5A (L1E5A ATOH)
			OR A						; Esegue OR di A
			JP NZ,SNERR					; Se diverso da zero, passa a 0x1997 (L1997 SNERR)
			EX DE,HL					; Scambia DE ed HL
			DEC HL						; Decrementa HL
			LD A,0x8F					; Carica in A il valore 0x8F
			LD B,(HL)					; Carica in B il valore puntato da (HL)
			LD (HL),A					; Salva A in memoria puntata da (HL)
			CP (HL)						; Compara A con valore puntato da (HL)
			LD (HL),B					; Salva B in memoria puntata da (HL)
			JR NZ,L00B5					; Se diverso, passa a 0x00B5, ripete input
			;
SETRAM		DEC HL						; Decrementa HL
			LD DE,UNK10					; Carica in DE il valore 0x4414 (UNK10)
			RST VCPDEHL					; Chiama la RST 0x18 (L0018 VCPDEHL)
			JP C,OMERR					; Se CY=1, passa a 0x197A (L197A OMERR)
			LD DE,0xFFCE				; Carica in DE il valore 0xFFCE (-50)
			LD (EOFRAM),HL				; Salva HL in memoria puntata da (0x40B1) EOFRAM	; Save End of RAM EOFRAM
			ADD HL,DE					; Somma DE ad HL
			LD (STRSPC),HL				; Salva HL in memoria puntata da (0x40A0) STRSPC
			CALL CLRPTR					; Chiama la 0x1B4D (L1B4D CLRPTR)
			;
			; Init hello message
			;
			LD HL,MNEBAS				; Carica in HL il valore 0x0111 (messaggio 'NUOVA ELETTRONICA BASIC 16')
			CALL PRS					; Chiama la 0x28A7 (L28A7 PRS)
			JP INICFG					; Passa a 0x0551 (L0551 INICFG)

MMEMSIZ		.TEXT 'MEMORY SIZE', 0x00
MNEBAS		.TEXT 'NUOVA ELETTRONICA BASIC 16', 0x0D, 0x00

			;
			; Routine 0x012D - SNERR2  Errore 0x2C Syntax Error
			;
SNERR2		LD E,ECOD2C					; Carica in E il valore 0x2C (codice errore 0x2C Syntax error)
			JP MSGERR					; Passa alla 0x19A2 (L19A2 MSGERR)

			;
			; Routine 0x0132 - POINT 
			;
POINT 		RST VGETCH					; Chiama la RST 0x10 (L0010 VGETCH)
			XOR A						; Azzera A
			.BYTE 0x01					; Skip prossima istruzione

			;
			; Routine 0x0135 - SET
			;
			; SET
SET			LD A,0x80					; Carica in A il valore 0x80
			.BYTE 0x01					; Skip prossima istruzione
			
			;
			; Routine 0x0138 - RESET
			;
RESET		LD A,0x01					; Carica in A il valore 0x01
										;  continua con la 0x013A (L013A CMNPSR)
			
			;
			; Routine 0x13A - CMNPSR  Parte comune POINT/SET/RESET
			;   Input: A 0x00 POINT, 0x80 SET, 0x81 RESET
			;
CMNPSR		PUSH AF						; Salva AF nello stack
			RST VCKCHAR					; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE '(' 					; (Carattere '(')
			CALL GETBYT					; Chiama la 0x2B1C (L2B1C GETBYT)
			CP 0x40						; Compara A con il valore 0x40
			JP NC,IFERR					; Se CY=0, passa alla 0x1E4A (L1E4A IFERR)
			PUSH AF						; Saòva AF nello stack
			RST VCKCHAR					; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','					; (Carattere ',')
			CALL GETBYT					; Chiama la 0x2B1C (L2B1C GETBYT)
			CP '0'						; Compara A con il valore 0x30 (carattere '0')
			JP NC,IFERR					; Se CY=0, passa alla 0x1E4A (L1E4A IFERR)
			LD D,A						; Copia A in D
			POP AF						; Recupera AF dallo stack
			LD E,A						; Copia A in E
			POP AF						; Recupera AF dallo stack
			PUSH HL						; Salva HL nello stack
			PUSH AF						; Salva AF nello stack
			LD A,D						; Copia D in A
			SRL E						; Esegue shift di E a destra di 1 bit
			LD D,0x00					; Azzera D
			JR NC,L015E					; Se CY=0, passa a 0x015E
			INC D						; Incrementa D
L015E		LD B,0xFF					; Carica in B il valore 0xFF
L0160		INC B						; Incrementa B
			SUB 0x03					; Sottrae da A il valore 0x03
			JP P,L0160					; Se positivo, passa a 0x0160
			ADD A,0x03					; Somma ad A il valore 0x03
			RLCA						; Ruota a sinistra A di 1 bit
			ADD A,D						; Somma D ad A
			LD C,A						; Copia A in C
			LD L,B						; Copia B in L
			LD H,0x00					; Azzera H
			LD B,0x05					; Carica in B il valore 0x05 (moltiplica HL per 32)
L0170		ADD HL,HL					; Raddoppia HL
			DJNZ L0170					; Decrementa B, se diverso da zero passa a 0x0170
			LD D,0x00					; Azzera D
			ADD HL,DE					; Somma DE ad HL
			LD DE,VIDBASE				; Carica in DE il valore 0xEC00 (puntatore base memoria video VIDBASE)
			ADD HL,DE					; Somma DE ad HL
			CALL RCHRAM					; Chiama la 0x041F (L041F RCHRAM)
			CP 0xC0						; Compara A con il valore 0xC0
			JR NC,L0185					; Se CY=0, passa a 0x0185
			CP 0x80						; Compara A con il valore 0x80
			JR NC,L0187					; Se CY=0, passa a 0x0187
L0185		LD A,0x80					; Carica in A il valore 0x80
L0187		LD B,A						; Copia A in B
			POP AF						; Recupera AF dallo stack
			OR A						; Esegue OR di A
			LD A,B						; Copia B in A
			LD B,0x00					; Azzera B
			JP L3233					; Passa alla 0x3233 (L3233 DORSP)

			; NOP da 0x0190 a 0x019B
			;
			DEFS 0x0C, 0x00

			RST VVECSYS					; (Non utilizzata)

			; 
			; Routine 0x019D - INKEY$ 
			;
INKEY 		RST VGETCH					; Chiama la RST 0x10 (L0010 VGETCH)
			PUSH HL						; Salva HL nello stack
			LD A,(LSTKEY)				; Carica in A da memoria puntata da (0x4099) LSTKEY
			OR A						; Esegue OR di A
			JR NZ,L01AB					; Se diverso da zero, passa a 0x01AB
			CALL GETK					; Chiama la 0x0358 (L0358 GETK)
			OR A						; Esegue OR di A
			JR Z,L01BC					; Se zero, passa a 0x01BC
										; Tasto premuto
L01AB		PUSH AF						; Salva AF nello stack
			XOR A						; Azzera A
			LD (LSTKEY),A				; Azzera memoria puntata da (0x4099) LSTKEY
			INC A						; Incrementa A
			CALL MKTMPSTR				; Chiama la 0x2857 (L2857 MKTMPSTR)
			POP AF						; Recupera AF dallo stack
			LD HL,(TSADD)				; Carica in HL da memoria puntata da (0x40D4) TSADD
			LD (HL),A					; Salva A in memoria puntata da (HL), salva carattere contenuto stringa
			JP L2884					; Passa a 0x2884 (L2884 TSTOPL)
										; Restituisce puntatore a stringa NULLA in FPREG
L01BC 		LD HL,MNULST				; Carica in HL il valore 0x1928 (puntatore a MNULST)
			LD (FPREG),HL				; Salva HL in memoria puntata da (0x4121) FPREG
			LD A,0x03					; Carica in A il valore 0x03 (tipo stringa)
			LD (TYPE),A					; Salva A in memoria puntata da (0x40AF) TYPE
			POP HL						; Recupera HL dallo stack
			RET							; Ritorna

			;
			; Routine 0x01C9 - CLS
			;
CLS			LD A,CHHM					; Carica in A il valore 0x1C (carattere <HOME>)
			CALL VCHPOS					; Chiama la 0x033A (L033A VCHPOS)
			LD A,CHES					; Carica in A il valore 0x1F (carattere <EOS>)
			JP VCHPOS					; Passa alla 0x033A (L033A VCHPOS)

			;
			; Routine 0x01D3 - RANDOM
			;			
RANDOM		LD A,R						; Copia R in A
			LD (RNDVAL),A				; Copia A in memoria puntata da (0x40AB) RNDVAL
			RET							; Ritorna

			; NOP da 0x01D9 a 0x01F4
			;
			DEFS 0x1C, 0x00

			;
			; Routine 0x01F5 - DELS18  Ritardo e invio 0x18 su cassetta
			;
DELS18		CALL DELAY					; Chiama la 0x31F4 (L31F4 DELAY)
										;   continua con la 0x01F8 (L01F8 VSNDTAPE18)

			;
			; Routine 0x01F8 - VSNDTAPE18 Invio 0x18 su cassetta
			;
VSNDTAPE18	JP SNDTAPE18				; Passa alla 0x3175 (L3175 SNDTAPE18)
			
			; NOP da 0x01FB a 0x01FD
			;
			DEFS 0x03, 0x00

			; Vettore VSETCHO
VSETCHO		JP SETCHO					; Passa alla 0x317A (L317A SETCHO)

			; NOP da 0x0201 a 0x022B
			;
			DEFS 0x2B, 0x00

			; Vettore VLAMPTAPE
L022C		JP L31B9					; Passa alla 0x31B9 (L31B9 LAMPTAPE)

			; NOP da 0x022F a 0x0234
			;
			DEFS 0x06, 0x00

			; Vettore VRDTAPE 0x0235
VRDTAPE		JP RDTAPE					; Passa alla 0x31E0 (L31E0 RDTAPE)

			; NOP da 0x0238 a 0x0260
			;
			DEFS 0x29, 0x00

			; Vettore VWRTAPE2 0x0261
VWRTAPE2	JP WRTAPE2					; Passa alla 0x31C2 (L31C2 WRTAPE2)

			; Vettore VWRTAPE 0x0264
VWRTAPE		JP WRTAPE					; Passa alla 0x31C5 (L31C5 WRTAPE)

			; NOP da 0x0267 a 0x0283
			;
			DEFS 0x1D, 0x00

			; Vettore VOUTTAP
VOUTTAP		JP OUTTAP					; Passa alla 0x31AB (L31AB OUTTAP)

			; NOP da 0x0287 a 0x0292
			;
			DEFS 0x0C, 0x00

			; Vettore VTPNOUT
VTPNOUT		JP L3198					; Passa alla 0x3198 (L3198 TPNOUT)

			; NOP da 0x0296 a 0x029E
			;
L0296		DEFS 0x09, 0x00

			; Vettore VVISAST
L029F		JP L31A2					; Passa alla 0x31A2 (L31A2 VISAST)

			; NOP da 0x02A2 a 0x02A8
			;
			DEFS 0x07, 0x00

			;
			; (codice non usato)
			;
			CALL 0x0314
			LD (PCODE2RUN),HL
			CALL VSNDTAPE18

			; 
			; Routine 0x02B2 - SYSTEM
			;
SYSTEM		LD HL,PRNSTAT				; Carica in HL il valore 0x4166 (PRNSTAT)
			LD B,0x22					; Carica in B il valore 0x22 (34 locazioni)
L02B7		LD (HL),0x00				; Azzera memoria puntata da (HL)
			INC HL						; Incrementa HL
			DJNZ L02B7					; Decrementa B, se diverso da zero passa a 0x02B7
			;
			LD (SPTMP2),SP				; Salva SP in memoria puntata da (0x417F) SPTMP2
			LD (TMSPSYS),SP				; Salva SP in memoria puntata da (0x416F) TMSPSYS
			LD HL,SYSMNU				; Carica in HL il valore 0x02DE (puntatore a SYSMNU)
			LD (TMPRAD),HL				; Salva HL in memoria puntata da (0x4171) TMPRAD
			CALL MONVCR					; Chiama la 0x3656 (L3656 MONVCR)
			LD HL,ENVECSYS				; Carica in HL il valore 0x355D (L355D ENVECSYS per VECSYS)
			LD (0x400D),HL				; Salva HL in memoria puntata da (0x400D)
			LD A,0xC3					; Carica in A il valore 0xC3 (Opcode JP per VECSYS)
			LD (0x400C),A				; Salva A in memoria puntata da (0x400C) VECSYS
			LD HL,MNEMON				; Carica in HL il valore 0x3724 (puntatore a messaggio MONITOR)
			CALL L3642					; Chiama la 0x3642 (L3642 MONMSG)
										;   continua con la 0x02DE (L02DE SYSMNU)
			
			;
			; Routine 0x02DE - SYSMNU  Gestisce comandi da tastiera per SYSTEM
			;
SYSMNU		LD SP,(SPTMP2)				; Carica in SP da memoria puntata da (0x417F) SPTMP2
			LD HL,0x02DE				; Carica in HL il valore 0x02DE (puntatore a SYSMNU)
			PUSH HL						; Salva HL nello stack
			PUSH HL						; Salva HL nello stack
			CALL MONVCR					; Chiama la 0x3656 (L3656 MONVCR)
			LD C,0x3E					; Carica in C il valore 0x3E (carattare '>')
			CALL VISHCPR				; Chiama la 0x3622 (L3622 VISHCPR)
			CALL WKAKPR					; Chiama la 0x36BD (L36BD WKAKPR)
			SUB 'A'						; Sottrae da A il valore 0x41 (carattere 'A')
			JP C,MONPPT					; Se CY=1, passa a 0x3692 (L3692 MONPPT)
			CP 0x13						; Compara A con il valore 0x13 
			JP NC,MONPPT				; Se CY=0, passa a 0x3692 (L3692 MONPPT)
			ADD A,A						; Raddoppia A
			LD E,A						; Copia A in E
			LD D,0x00					; Azzera D
			LD B,0x02					; Carica in B il valore 0x02
			LD HL,TCMDMON				; Carica in HL il valore 0x3738 (Tabella comandi Monitor TCMDMON)
			ADD HL,DE					; Somma DE ad HL
			LD A,(HL)					; Carica in A da memoria puntata da (HL)
			INC HL						; Incrementa HL
			LD H,(HL)					; Carica in H da memoria puntata da (HL)
			LD L,A						; Copia A in L
			JP (HL)						; Passa a indirizzo puntato da (HL)

			;
			; Routine 0x030B - MONRET	Comando B di SYSTEM
			;							B
			;							Ritorna dal Monitor al BASIC
			;
MONRET		LD A,0xC9					; Carica in A il valore 0xC9 (Opcode RET per VECSYS)
			LD (0x400C),A				; Salva A in memoria puntata da (0x400C) VECSYS
			CALL MONVCR					; Chiama la 0x3656 (L3656 MONVCR)
			JP BASMAIN					; Passa alla 0x1A19 (L1A19 BASMAIN)
			
			; 
			; Routine 0x0316 - SYSPRNON		Comando P di SYSTEM
			;								P
			;								Attiva l'hardcopy su stampante
			;
SYSPRNON	LD A,0x01					; Carica in A il valore 0x01
			JR L031B					; Passa a 0x031B

			; 
			; Routine 0x031A - SYSPRNOFF	Comando Q di SYSTEM
			;								Q
			;								Disattiva l'hardcopy su stampante
			;
SYSPRNOFF	XOR A						; Azzera A
L031B		LD (PRNSTAT),A				; Azzera memoria puntata da (0x4166) PRNSTAT
			RET							; Ritorna

			; 
			; Routine 0x031F - SYSFILL	Comando F del monitor?
			;							F ind1,ind2,dat  
			;							Pone in memoria
			;							dall'indirizzo ind1 (hex) all'indirizzo ind2 (hex)
			;							il dato dat (hex)
			;
SYSFILL		CALL SYSGETIID				; Chiama la 0x36C8 (L36C8 SYSGETIID)
SYSFLP		LD (HL),C					; Salva C in memoria puntata da (HL)
			CALL INCHLCMPDE				; Chiama la 0x36D1 (L36D1 INCHLCMPDE)
			JR NC,SYSFLP				; Se CY=0, passa a 0x0322 (L0322 SYSFLP), loop riempimento memoria
			RET							; Ritorna

			; Non utilizzato
			NOP				;

			;
			; Routine 0x032A - OUTCHA Visualizza carattere ASCII in A
			;  Input: A carattere
			;
OUTCHA		PUSH BC						; Salva BC nello stack
			LD C,A						; Copia A in C
			NOP     					;
			NOP     					;
			NOP     					;
			LD A,(DEVOUT)				; Carica in A da memoria puntata da (0x409C) DEVOUT
			OR A						; Esegue OR di A
			LD A,C						; Copia C in A
			POP BC						; Recupera BC dallo stack
			JP M,VWRTAPE				; Se negativo (0x80), passa alla 0x0264 (L0264 VWRTAPE)
			JR NZ,PRCH					; Se diverso da zero (0x01), passa alla 0x039C (L039C PRCH)
										;   altrimenti, se zero (0x00), continua con 0x033A (L033A VCHPOS)

			;
			; Routine 0x033A - VCHPOS  Visualizza carattere e modifica posizione corrente
			;    input: A carattere
			;
VCHPOS		PUSH DE						; Salva DE nello stack
			CALL HIOSCR					; Chiama la 0x0033 (L0033 HIOSCR)
			PUSH AF						; Salva AF nello stack
			CALL GETSCCOL				; Chiama la 0x0348 (L0348 GETSCCOL)
			LD (CURPOS),A				; Salva A in memoria puntata da (0x40A6) CURPOS
			POP AF						; Recuper AF dallo stack
			POP DE						; Recuper DE dallo stack
			RET     					; Ritorna

			;
			; Routine 0x0348 - GETSCCOL  Ottiene in A la colonna attuale dello schermo
			;
GETSCCOL	LD A,(CHNNO)				; Carica A da (0x403D) CHNNO
			AND 0x08					; Esegue AND con il valore 0x08 (out device Tape) (codice inutilizzato)
			LD A,(SCRCURR)				; Carica A da (0x4020) SCRCURR
			NOP     					;
			NOP     					;
			NOP     					;
			AND 0x1F					; Esegue AND con il valore 0x1F (32 colonne nel video)
			AND 0x3F					; Esegue AND con il valore 0x3F (non utilizzato)
			RET     					; Ritorna

			;
			; Routine 0x0358 - GETK  Check input da tastiera
			;   Output: A 00 nessun tasto oppure >00 codice tasto
			;
GETK		NOP     					;
			NOP     					;
			NOP     					;
			PUSH DE						; Salva DE nello stack
			CALL GETKHW					; Chiama la 0x002B (L002B GETKHW)
			POP DE						; Recupera DE dallo stack
			RET     					; Ritorna

			; 
			; Routine 0x0361 - GETLINE  Input linea da tastiera
			;    Output: HL = indirizzo iniziale buffer-1
			;			  A = 0 e CY = 0 ?
			;			 CY = 1 ?
			;
GETLINE		XOR A						; Azzera A
			LD (LSTKEY),A				; Azzera memoria puntata da (0x4099) LSTKEY, azzera ultimo tasto pressato
			LD (CURPOS),A				; Azzera memoria puntata da (0x40A6) CURPOS, azzera posizione corrente cursore
			NOP     					;
			NOP     					;
			NOP     					;
			PUSH BC						; Salva BC nello stack
			LD HL,(PBUFFER)				; Carica HL da (0x40A7) PBUFFER, (valore 0x41E8 => PREBUFFER+3 => BUFFER)
			LD B,MAXLENBUF				; Carica in B il valore 0xF0 (Massima lunghezza buffer, MAXLENBUF)
			CALL KYPARSE				; Chiama la 0x05D9 (L05D9 KYPARSE)
			PUSH AF						; Salva AF nello stack
			LD C,B						; Copia B in C (in B => C lunghezza input)
			LD B,0x00					; Azzera B, in BC lunghezza buffer
			ADD HL,BC					; Somma BC ad HL
			LD (HL),0x00				; Azzera (HL), salva EOL a fine linea nel buffer
			LD HL,(PBUFFER)				; Carica HL da (0x40A7) PBUFFER, (valore 0x41E8 => PREBUFFER+3 => BUFFER)
			POP AF						; Recupera AF dallo stack
			POP BC						; Recupera BC dallo stack
			DEC HL						; Decrementa HL
			RET C						; Se CY=1, ritorna
			XOR A						; Azzera A
			RET     					; Ritorna

			;
			; Routine 0x0384 - WTAKEY  Attende tasto
			;
WTAKEY		CALL GETK					; Chiama la 0x0358 (L0358 GETK)
			OR A						; Esegue OR di A
			RET NZ						; Se diverso da zero, ritorna
			JR WTAKEY					; Passa a 0x0384 (L0384 WTAKEY)

			;
			; Routine 0x038B - RESPRN  Reset stampante 
			;
RESPRN		XOR A						; Azzera A (uscita su video)
			LD (DEVOUT),A				; Azzera memoria puntata da (0x409C) DEVOUT
			LD A,(CPOSPRN)				; Carica in A da (0x409B) CPOSPRN
			OR A						; Esegue OR di A
			RET Z						; Se uguale a zero, ritorna
			LD A,CHCR					; Carica in A il valore 0x0D (carattere <CR>)
			PUSH DE						; Salva DE nello stack
			CALL PRCH					; Chiama la 0x039C (L039C PRCH)
			POP DE						; Recupera DE dallo stack
			RET    						; Ritorna

			;
			; Routine 0x039C - PRCH  Invia carattere a stampante
			;   Input: A carattere in stampa (gestisce <LF>, <FF>, <CR>)
			;
PRCH		PUSH AF						; Salva AF nello stack
			PUSH DE						; Salva DE nello stack
			PUSH BC						; Salva BC nello stack
			LD C,A						; Copia A in C
			LD E,0x00					; Azzera E
			CP CHFF						; Compara A con il valore 0x0C (carattere <FF>)
			JR Z,L03B6					; Se uguale, passa a 0x03B6
			CP CHLF						; Compara A con il valore 0x0A (carattere <LF>)
			JR NZ,L03AD					; Se diverso, passa a 0x03AD
			LD A,CHCR					; Altrimenti, carica in A il valore 0x0D (carattere <CR>)
			LD C,A						; Copia A in C
L03AD		CP CHCR						; Compara A con il valore 0x0D (carattere <CR>)
			JR Z,L03B6					; Se uguale, passa a 0x03B6
			LD A,(CPOSPRN)				; Carica in A da (0x409B) CPOSPRN
			INC A						; Incrementa A
			LD E,A						; Copia A in E
L03B6		LD A,E						; Copia E in A
			LD (CPOSPRN),A				; Salva A in (0x409B) CPOSPRN
			LD A,C						; Copia C in A
			CALL HPRCHAR				; Chiama la 0x003B (L003B HPRCHAR)
			POP BC						; Recupera BC dallo stack
			POP DE						; Recupera DE dallo stack
			POP AF						; Recupera AF dallo stack
			RET     					; Ritorna

			;
			; Routine 0x03C2 - SVCIO  Chiama indirettamente servizio selezionato da HL e B
			;   Input: DE Tabella in memoria per servizio, B 0x01, 0x02, 0x04 tipo servizio
			;
SVCIO		PUSH HL						; Salva HL nello stack
			PUSH IX						; Salva IX nello stack
			PUSH DE						; Salva DE nello stack
			POP IX						; Recupera IX dallo stack
			PUSH DE						; Salva DE nello stack
			LD HL,POPREENT				; Carica in HL il valore 0x03DD (L03DD POPREENT)
			PUSH HL						; Salva HL nello stack
			;
			LD C,A						; Copia A in C
			LD A,(DE)					; Carica in A memoria puntata da (DE)
			AND B						; Esegue AND di A con B
			CP B						; Compara A con B
			JP NZ,ZEROA					; Se diverso, passa a 0x4033 (L4033 ZEROA)
			CP 0x02						; Compara A con il valore 0x02
			; Salto indiretto
			LD L,(IX+0x01)				; Carica L da memoria puntata da (IX+0x01)
			LD H,(IX+0x02)				; Carica H da memoria puntata da (IX+0x02)
			JP (HL)						; Passa a indirizzo puntato da (HL)
			;
			; Punto rientro dopo salto indiretto
POPREENT	POP DE						; Recupera DE dallo stack
			POP IX						; Recupera IX dallo stack
			POP HL						; Recupera HL dallo stack
			POP BC						; Recupera BC dallo stack
			RET     					; Ritorna

			;
			; Routine 0x03E3 - INHWKB  Input hw da tastiera
			;
INHWKB		IN A,(PORT_KBDIN)			; Input in A da porta 0xEA (Interfaccia tastiera)
			AND 0x80					; Esegue AND di A con valore 0x80 (test bit 7 STROBE)
			RET Z						; Se zero, ritorna 
			IN A,(PORT_KBDIN)			; Input in A da porta 0xEA (Interfaccia tastiera)
			RES 7,A						; Reset bit 7 di A
			PUSH AF						; Salva AF nello stack
L03ED		IN A,(PORT_KBDIN)			; Input in A da porta 0xEA (Interfaccia tastiera)
			BIT 7,A						; Test bit 7 di A
			JR NZ,L03ED					; Se diverso da zero, passa a 0x03ED, attende
			POP AF						; Recupera AF dallo stack
			RET     					; Ritorna

			; 
			; Routine 0x03F5 - IOSCR Input/Output carattere video
			;  Input: CY=0 Scrive carattere, C carattere, IX+03/IX+04 posizione - Output: A carattere scritto
			;  Input: CY=1 Legge carattere, IX+03/IX+04 posizione - Output: A carattere letto
			;
IOSCR		LD L,(IX+0x03)				; Carica in L da memoria puntata da (IX+0x03)
			LD H,(IX+0x04)				; Carica in H da memoria puntata da (IX+0x04)
			JR C,RCHRAM					; Se CY=1, passa alla 0x041F (L041F RCHRAM)
			LD A,C						; Copia C in A
			CP ' '						; Compara A con il valore 0x20 (carattere ' ')
			JP C,L0464					; Se CY=1, passa a 0x0464 (L0464 ACTBYCH)
			CP 0x60						; Compara A con il valore 0x60 
			JP M,L040F					; Se negativo, passa a 0x040F
			CP 0x7B						; Compara A con il valore 0x7B
			JP P,L040F					; Se positivo, passa a 0x040F
			RES 5,A						; Reset bit 5 di A (rende carattere maiuscolo)
L040F		CALL L0427					; Chiama la 0x0427 (L0427 WCHRAM)
			;
L0412		LD A,0x81					; Carica in A il valore 0x81 
			CALL OUTCHVD				; Chiama la 0x044E (L044E OUTCHVD)
			LD (IX+0x03),L				; Salva L in memoria puntata da (IX+0x03)
			LD (IX+0x04),H				; Salva H in memoria puntata da (IX+0x04)
			LD A,C						; Copia C in A, carattere originale in A
			RET     					; Ritorna

			;
			; Routine 0x041F - RCHRAM  Lettura carattere da RAM sincronizzata
			;   Input:  HL posizione di lettura 
			;   Output: A carattere letto
			;
RCHRAM		IN A,(PORT_VSYNC)			; Input in A da porta 0xEB (Interfaccia ritraccia video)
			BIT 7,A						; Test bit 7 di A
			JR NZ,RCHRAM				; Se diverso da zero, passa a 0x041F (LRCHRAM), attende
			LD A,(HL)					; Carica in A da memoria puntata da (HL)
			RET							; Ritorna

			;
			; Routine 0x0427 - WCHRAM  Scrive carattere in RAM
			;   Input:  HL posizione scrittura carattere, A carattere da scrivere
			;   Output: HL posizione aggiornata
			;
L0427		CALL OUTCHVD				; Chiama la 0x044E (L044E OUTCHVD)
			INC HL						; Incrementa HL
										;   continua con la 0x042B (L042B CKSCROLL)

			;
			; Routine 0x042B - CKSCROLL  Esegue eventuale scroll
			;   Output: HL posizione aggiornata
			;
CKSCROLL	LD A,H						; Copia H in A
			CP VHIGH					; Compara A con il valore 0xEE (parte alta indirizzo memoria video oltre ultima riga)
			RET NZ						; Se diverso, ritorna
			LD DE,VIDBASE				; Carica in DE il valore 0xEC00 (puntatore base memoria video VIDBASE)
			LD HL,VIDBASE+0x20			; Carica in HL il valore 0xEC20 (puntatore base+0x20 memoria video, seconda riga)
			LD B,0x04					; Carica in B il valore 0x04
L0437		PUSH BC						; Salva BC nello stack
			LD BC,0x0078				; Carica in BC il valore 0x0078
L043B		IN A,(PORT_VSYNC)			; Input in A da porta 0xEB (Interfaccia ritraccia video)
			BIT 7,A						; Test bit 7 di A
			JR NZ,L043B					; Se diverso da zero, passa a 0x043B, attende
			LDIR    					; Copia 0x78 byte da 0xEC20 in 0xEC00 (e seguenti, DE e HL aggiornati)
			POP BC						; Recupera BC dallo stack
			DJNZ L0437					; Decrementa B, se diverso da zero passa a 0x0437
			EX DE,HL					; Scambia DE ed HL
			CALL CLTOENDRW				; Chiama la 0x0458 (L0458 CLTOENDRW)
			LD HL,VIDBASE+15*0x20		; Carica in HL il valore 0xEDE0 (puntatore ad inizio ultima riga)
			RET     					; Ritorna

			;
			; Routine 0x044E - OUTCHVD Scrittura carattere in RAM video sincronizzata
			;  Input: HL posizione di scrittura, A carattere da scrivere
			;
OUTCHVD		PUSH AF						; Salva AF nello stack
L044F		IN A,(PORT_VSYNC)			; Input in A da porta 0xEB (Interfaccia ritraccia video)
			BIT 7,A						; Test bit 7 di A
			JR NZ,L044F					; Se diverso da zero, passa a 0x044F, attende
			POP AF						; Recupera AF dallo stack
			LD (HL),A					; Salva A in memoria puntata da (HL)
			RET     					; Ritorna

			;
			; Routine 0x0458 - CLTOENDRW Cancella video fino a fine linea
			;  Input: HL posizione su schermo
			;
CLTOENDRW	LD A,' '					; Carica in A il valore 0x20 (carattere ' ')
			CALL OUTCHVD				; Chiama la 0x044E (L044E OUTCHVD)
			INC HL						; Incrementa HL (prossima posizione su schermo)
			LD A,L						; Copia L in A
			AND 0x1F					; Esegue AND di A con il valore 0x1F
			JR NZ,CLTOENDRW				; Se diverso da zero, passa a 0x0458 (L0458 CLTOENDRW)
			RET     					; Ritorna

			;
			; Routine 0x0464 - ACTBYCH  Esegue azione in base a carattere in input
			;   Input: A carattere di controllo
			;   Output: HL posizione prossimo carattere
			;
L0464		LD DE,0x0412				; Carica in DE il valore 0x412
			PUSH DE						; Salva DE nello stack
			CP CHBS						; Compara A con il valore 0x08 (carattere <BS>)
			JR Z,WR2SP					; Se uguale, passa a 0x0480 (L0480 WR2SP)
			CP CHLF						; Compara A con il valore 0x0A (carattere <LF>)
			RET C						; Se CY=1, ritorna
			CP CHPN						; Compara A con il valore 0x0E (carattere <PGN>)
			JR C,L0499					; Se CY=1, passa a 0x0499 (L0499 CLTOENDRWSC)
			CP CHHM						; Compara A con il valore 0x1C (carattere <HOME>)
			JR Z,L048A					; Se uguale, passa a 0x048A (L048A GETVMEM)
			CP CHEL						; Compara A con il valore 0x1E (carattere <EOL>)
			JR Z,CLTOENDRW				; Se uguale, passa a 0x0458 (L0458 CLTOENDRW)
			CP CHES						; Compara A con il valore 0x1F (carattere <EOS>)
			JR Z,CLTOENDSC				; Se uguale, passa a 0x048E (L048E CLTOENDSC)
			RET     					; Ritorna

			;
			; Routine 0x0480 - WR2SP  Scrive spazio su posizione attuale e precedente 
			;  Input: HL posizione su schermo
			;
WR2SP		LD A,' '					; Carica in A il valore 0x20 (carattere ' ')
			CALL OUTCHVD				; Chiama la 0x044E (L044E OUTCHVD)
			DEC HL						; Decrementa HL, posizione precedente su schermo
			CALL OUTCHVD				; Chiama la 0x044E (L044E OUTCHVD)
			RET     					; Ritorna

			;
			; Routine 0x048A - GETVMEM  Ottiene base memoria video
			;  Output: HL indirizzo base memoria video
			;
L048A		LD HL,VIDBASE				; Carica in HL il valore 0xEC00 (puntatore base memoria video VIDBASE)
			RET							; Ritorna     

			;
			; Routine 0x048E - CLTOENDSC  Cancella fin a fine schermo
			;
CLTOENDSC	PUSH HL						; Salva HL nello stack
L048F		CALL CLTOENDRW				; Chiama la 0x0458 (L0458 CLTOENDRW)
			LD A,H						; Copia H in A
			CP VHIGH					; Compara A con il valore 0xEE (parte alta indirizzo memoria video oltre ultima riga)
			JR NZ,L048F					; Se diverso, passa a 0x048F, ciclo cancellazione
			POP HL						; Recupera HL dallo stack
			RET     					; Ritorna

			;
			; Routine 0x0499 - CLTOENDRWSC Cancella video fino a fine linea con eventuale scroll
			;
L0499		CALL CLTOENDRW				; Chiama la 0x0458 (L0458 CLTOENDRW)
			JP CKSCROLL					; Passa a 0x042B (L042B CKSCROLL)

			;
			; Routine 0x049F - PRCHAR Invia un carattere su stampante
			;   Input: C carattere da stampare
			;
PRCHAR		LD A,C						; Copia C in A
			OR A						; Esegue OR di A
			JR Z,RDIN03					; Se zero, passa a 0x04C1 (L04C1 RDIN03)
L04A3		CALL RDIN03					; Chiama la 0x04C1 (L04C1 RDIN03)
			JR NZ,L04A3					; Se diverso da zero, passa a 0x04A3 (ciclo)
			LD A,C						; Copia C in A
			SET 7,A						; Imposta bit7 di A uguale a 1
			OUT (PORT_PRINT),A			; Out di A su porta 0x03 (interfaccia stampante)
			RES 7,A						; Imposta bit7 di A uguale a 0
			OUT (PORT_PRINT),A			; Out di A su porta 0x03 (interfaccia stampante)
			SET 7,A						; Imposta bit7 di A uguale a 1
			OUT (PORT_PRINT),A			; Out di A su porta 0x03 (interfaccia stampante)
			CP 0x80+CHCR				; Compara A con il vaore 0x8D (carattere 0x80+<CR>)
			RET NZ						; Se diverso, ritorna
			LD A,(VARLF)				; Carica in A da memoria puntata da (0x4028) VARLF
			OR A						; Esegue OR di A
			RET Z						; Se zero, ritorna
			LD C,0x0A					; Carica in C il valore 0x0A (carattere LF)
			JR L04A3					; Passa a 0x04A3, stampa anche LF

			;
			; Routine 0x04C1 - RDIN03  Legge da porta 0x03 (interfaccia stampante), restituisce bit0 
			;
RDIN03		IN A,(0x03)					; Input in A da porta 0x03 (interfaccia stampante)
			AND 0x01					; Esegue AND di A con il valore 0x01 (test bit0)
			BIT 0,A						; Test bit0 di A
			RET    						; Ritorna

			; NOP da 0x04C8 a 0x0550 
			;
			DEFS 0x89, 0x00

			; 
			; Routine 0x0551 - INICFG
			;
INICFG		LD HL,MUSELF				; Carica in HL il valore 0x056F (messaggio 'USE LINEFEED (Y/N)')
			CALL PRS					; Chiama la 0x28A7 (L28A7 PRS)
			CALL VISPPIN				; Chiama la 0x1BB3 (L1BB3 VISPPIN)
			RST VGETCH					; Chiama la RST 0x10 (L0010 VGETCH)
			RES 5,A						; Azzera bit 5 di A (carattere diventa minuscolo)
			CP 'N'						; Compara A con valore 0x4e (carattere 'N')
			JP Z,BASMAIN				; Se uguale, passa a 0x1A19 (L1A19 BASMAIN)
			CP 'Y'						; Compara A con valore 0x59 (carattere 'Y')
			JR NZ,INICFG				; Se diverso, passa a 0x0551 (L0551 INICFG), ripete input
			LD A,0x01					; Carica in A il valore 0x01 (LF YES)
			LD (VARLF),A				; Salva A in memoria puntata da (0x4028 VARLF)
			JP BASMAIN					; Passa a 0x1A19 (L1A19 BASMAIN)
			
			NOP							;

MUSELF		.TEXT 0x0D, 'USE LINEFEED (Y/N)', 0x00

			;
			; Routine 0x0583 - HCONV  Gestione carattere &, conversione decimale, ottale, esadecimale
			;
HCONV		LD DE,0x0000				; Azzera DE											; Zero temp result in DE
			RST VGETCH					; Chiama la RST 0x10 (L0010 VGETCH)
			CP 'O'						; Compara A con il valore 0x4F (carattere 'O')
			JR Z,OCTTFP					; Se uguale, passa a 0x05B7 (L05B7 OCTTFP)
			CP 'H'						; Compara A con il valore 0x48 (carattere 'H')
			JR NZ,OCTTFP2				; Se diverso, passa a 0x05B6 (L05B6 OCTFP2)
										;   altrimenti continua con 0x058F (L058F HEXTFP)
			
			;
			; Routine 0x058F - HEXTFP  Converte "&Hnnnn" in FPREG
			;
HEXTFP		LD B,0x05					; Carica in B il valore 0x05						; Max digits+1
L0591		INC HL						; Incrementa HL
			LD A,(HL)					; Carica in A memoria puntata da (HL)
			CALL L1E3E					; Chiama la 0x1E3E (L1E3E CKALTR)
			EX DE,HL					; Scambia DE ed HL									; Temp result in HL
			JR NC,L05A3					; Se CY=0, passa a 0x05A3
			CP ':'						; Compara A con il valore 0x3A (carattere ':')
			JR NC,L05D4					; Se CY=0, passa a 0x05D4							; Non hex digit
			SUB '0'						; Sottrae da A il valore 0x30 (carattere '0')
			JR C,L05D4					; Se CY=1, passa a 0x05D4							; Non hex digit
			JR L05A9					; Passa a 0x05A9									; Valid digit 0-9
			;
L05A3		CP 'F'+1					; Compara A con il valore 0x47 (carattere 'G', 'F'+1)
			JR NC,L05D4					; Se CY=0, passa a 0x05D4							; Non hex digit
			SUB '7'						; Sottrae da A il valore 0x37 (carattere '7')		; Valid digit A-F
			;
L05A9		ADD HL,HL					; Raddoppia HL										; Rotate 4 bits to the left
			ADD HL,HL					; Raddoppia HL
			ADD HL,HL					; Raddoppia HL
			ADD HL,HL					; Raddoppia HL
			OR L						; Esegue OR di A con L								; Add in D0-D3 into L
			LD L,A						; Copia A in L										; Save new value
			DEC B						; Decrementa B										; Digit counter
			JP Z,OVERR					; Se zero, passa a 0x07B2 (L07B2 OVERR)
			EX DE,HL					; Scambia DE ed HL									; DE temp result
			JR L0591					; Passa a 0x0591, prossima cifra esadecimale		; And continue until all hex characters are in
			
			;
			; Routine 0x05B6 - OCTTFP2  Converte "&nnnn" in FPREG
			;
OCTTFP2		DEC HL						; Decrementa HL
										;   continua con la 0x05B7 (L05B7 OCTTFP)
			
			;
			; Routine 0x05B7 - OCTTFP  Converte "&Onnnn" in FPREG
			;
OCTTFP		RST VGETCH					; Chiama la RST 0x10 (L0010 VGETCH)
			EX DE,HL					; Scambia DE ed HL									; Temp result in HL
			JR NC,L05D4					; Se CY=0, passa a 0x05D4							; Non oct digit
			CP '7'+1					; Compara A con il valore 0x38 (carattere '8', '7'+1)
			JP NC,SNERR					; Se CY=0, passa a 0x1997 (L1997 SNERR)				; Not 0-7 digit, syntax error
			LD BC,OVERR					; Carica in BC il valore 0x07B2 (L07B2 OVERR)
			PUSH BC						; Salva BC nello stack
			ADD HL,HL					; Raddoppia HL										; Multiply HL by 8
			RET C						; Se CY=1, ritorna									; OVERR
			ADD HL,HL					; Raddoppia HL
			RET C						; Se CY=1, ritorna									; OVERR
			ADD HL,HL					; Raddoppia HL
			RET C						; Se CY=1, ritorna									; OVERR
			POP BC						; Recupera BC dallo stack							; Clear stack from OVERR return
			LD B,0x00					; Azzera B
			SUB '0'						; Sottrae da A il valore 0x30 (carattere '0', converte da ASCII)
			LD C,A						; Copia A in C
			ADD HL,BC					; Somma BC ad HL									; Sum current digit in BC
			EX DE,HL					; Scambia DE ed HL									; DE temp result
			JR OCTTFP					; Passa a 0x05B7 (L05B7 OCTTFP), prossima cifra ottale	; And continue until all oct characters are in
			;
L05D4		CALL MVHL2FPR				; Chiama la 0x0A9A (L0A9A MVHL2FPR)					; Save HL to FPREG
			EX DE,HL					; Scambia DE ed HL	
			RET     					; Ritorna

			;
			; Routine 0x05D9 - KYPARSE  Attende tasto e lo gestisce
			;   Input:  HL = puntatore al buffer
			;		     B = massima lunghezza buffer
			;   Output:  B = numero caratteri nel buffer
			;		
KYPARSE		PUSH HL						; Salva HL nello stack
			LD A,CHPN					; Carica in A il valore 0x0E (<PGN>)
			CALL HIOSCR					; Chiama la 0x0033 (L0033 HIOSCR)
			LD C,B						; Copia B in C
KYPARSELP	CALL WTKEYA					; Chiama la 0x0049 (L0049 WTKEYA), attende input di un tasto
			CP ' '						; Compara A con il valore 0x20 (carattere ' ')
			JR NC,KYPLFOTH				; Se CY=0, passa a 0x060C (L060C KYPLFOTH), non è un tasto di controllo
										; Gestione tasti di controllo
			CP CHCR						; Compara A con il valore 0x0D (tasto <CR>)
			JP Z,KYPCR					; Se uguale, passa a 0x0662 (L0662 KYPCR), gestisce tasto <CR>
										;
			CP CHFF						; Compara A con il valore 0x0C (tasto <FF>)
			JR Z,KYPFF					; Se uguale, passa a 0x0619 (L0619 KYPFF), gestisce tasto <FF>
										;
			CP CHCC						; Compara A con il valore 0x03 (tasto <CTRLC>)
			JR Z,KYPCC					; Se uguale, passa a 0x0661 (L0661 KYPCC), gestisce tasto <CTRLC>
										;
			LD DE,KYPARSELP				; Carica in DE il valore 0x05E0 (punatore a L05E0 KYPARSELP)
			PUSH DE						; Salva DE nello stack
			CP CHBS						; Compara A con il valore 0x08 (tasto <BS>)
			JR Z,KYPBS					; Se uguale passa a 0x0630 (L0630 KYPBS), gestisce tasto <BS>
										;
			CP CHCX						; Compara A con il valore 0x18 (tasto <CTRLX>)
			JR Z,KYPCX					; Se uguale passa a 0x062B (L062B KYPCX), gestisce tasto <CTRLX>
										;
			CP CHTB						; Compara A con il valore 0x09 (tasto <TAB>)
			JR Z,KYPTAB					; Se uguale passa a 0x0646 (L0646 KYPTAB), gestisce tasto <TAB>
			NOP     					;
			NOP     					;
			NOP     					;
			NOP     					;
			CP CHLF						; Compara A con il valore 0x0A (tasto <LF>)
			RET NZ						; Se diverso, ritorna
			POP DE						; Recupera DE dallo stack (elimina punto di rientro)
			;
			; Tasto 0x0A <LF> e altri tasti memorizzabili
			; 
KYPLFOTH	LD (HL),A					; Salva A in memoria puntata da (HL)
			LD A,B						; Copia B in A
			OR A						; Esegue OR di A
			JR Z,KYPARSELP				; Se zero, passa a 0x05E0 (L05E0 KYPARSELP)
			LD A,(HL)					; Carica A da memoria puntata da (HL)
			INC HL						; Incrementa HL
			CALL HIOSCR					; Chiama la 0x0033 (L0033 HIOSCR)
			DEC B						; Decrementa B
			JR KYPARSELP				; Passa alla 0x05E0 (L05E0 KYPARSELP)
			;
			; Tasto 0x0C <FF>
			;
KYPFF		CALL CLS					; Chiama la 0x01C9 (L01C9 CLS)
			LD B,C						; Copia C in B
			POP HL						; Recupera HL dallo stack
			PUSH HL						; Salva HL nello stack
			JP KYPARSELP				; Passa a 0x05E0 (L05E0 KYPARSELP)
			;
			;
L0622		CALL KYPBS					; Chiama la 0x0630 (L0630, gestione tasto <BS>)
			DEC HL						; Decrementa HL
			LD A,(HL)					; Carica in A da memoria puntata da (HL)
			INC HL						; Incrementa HL
			CP CHLF						; Compara a con 0x0A (tasto <LF>)
			RET Z						; Se uguale, ritorna
			;
			; Tasto 0x18 <CTRLX>
			;
KYPCX 		LD A,B						; Copia B in A\
			CP C						; Compara A con C
			JR NZ,L0622					; Se diversi, passa a 0x0622
			RET     					; Ritorna

			; Tasto 0x08 <BS>
			;
KYPBS		LD A,B						; Copia B in A
			CP C						; Compara A con C
			RET Z						; Se uguale, ritorna (primo carattere, non si cancella)
			DEC HL						; Decrementa HL
			LD A,(HL)					; Carica in A da memoria puntata da (HL)
			CP CHLF						; Compara A con il valore 0x0A (carattere <LF>)
			INC HL						; Incrementa HL
			RET Z						; Se uguale, ritorna
			DEC HL						; Decrementa HL
			LD A,CHBS					; Carica in A il valore 0x08 (carattere <BS>)
			CALL HIOSCR					; Chiama la 0x0033 (L0033 HIOSCR)
			INC B						; Incementa B
			RET     					; Ritorna

			; NOP da 0x0641 a 0x645
			;
			DEFS 0x05, 0x00

			; Tasto 0x09 <TAB>
			;
KYPTAB		CALL GETSCCOL				; Chiama la 0x0348 (L0348 GETSCCOL)
			AND 0x07					; Esegue AND di A con valore 0x07
			CPL     					; Inverte A
			INC A						; Incrementa A
			ADD A,0x08					; Somma ad A il valore 0x08
			LD E,A						; Copia A in E
L0650		LD A,B						; Copia B in A
			OR A							; Esegue OR di A
			RET Z						; Se uguale a zero, ritorna
			LD A,0x20					; Carica in A il valore 0x20 (carattere ' ')
			LD (HL),A					; Salva A in memoria puntata da (HL)
			INC HL						; Incrementa HL
			PUSH DE						; Salva DE nello stack
			CALL HIOSCR					; Chiama la 0x0033 (L0033 HIOSCR)
			POP DE						; Recupera DE dallo stack
			DEC B						; Decrementa B
			DEC E						; Decrementa E
			RET Z						; Se zero, ritorna
			JR L0650					; Passa a 0x0650
			;
			; Tasto 0x03 <CTRLC>
			;
KYPCC 		SCF   						; Imposta CY=1
										;  continua con 0x0662
			;
			; Tasto 0x0D (CR)
			;
KYPCR		PUSH AF						; Salva AF nello stack
			LD A,CHCR					; Carica in A il valore 0x0D (carattere <CR>)
			LD (HL),A					; Salva A in memoria puntata da (HL)
			CALL HIOSCR					; Chiama la 0x0033 (L0033 HIOSCR)
			LD A,CHCO					; Carica in A il valore 0x0F (carattere <CTRLO>)
			CALL HIOSCR					; Chiama la 0x0033 (L0033 HIOSCR)
			LD A,C						; Copia C in A
			SUB B						; Sottrae da A il valore di B
			LD B,A						; Copia A in B, numero caratteri inseriti nel buffer
			POP AF						; Recupera AF dallo stack
			POP HL						; Recupera HL dallo stack
			RET 						; Ritorna    

			;
			; Routine 0x0674 - BASIC Inizializzazione BASIC
			;
BASIC		NOP 						;
			NOP     					;
			LD HL,SYSAREA				; Carica in HL puntatore a 0x06D2 (SYSAREA) L0676
			LD DE,VARINIT				; Carica in DE puntatore a 0x4000 (VARINIT)
			LD BC,SZSYSAREA				; Carica in BC il valore 0x0036 (SZSYSAREA)
			LDIR    					; Copia 0x0036 byte da 0x06D2 in 0x4000
			;
			NOP							; DEC A Decrementa A 
			NOP							; DEC A	; Decrementa A 
			NOP							;
			NOP							; JR NZ,L0676 Se A diverso da zero, passa a L0676 (Crea un ritardo al RESET?)
			;
			LD B,0x27					; Carica 0x27 in B (numero byte da azzerare) (Azzera da 0x4036 a 0x405C)
ZVAR		LD (DE),A					; Azzera (DE) a partire da 0x4036
			INC DE						; Incrementa DE
			DJNZ ZVAR					; Decrementa B, se diverso da zero passa a 0x0687 (L0687 ZVAR)
			;
			JP BASIC2					; Passa a 0x0075 (L0075 BASIC2)

			; NOP da 0x068E a 0x06CB
			;
			DEFS 0x11, 0x00
L069F		DEFS 0x2D, 0x00

			;
			; Routine 0x06CC - HDLNMI  Gestisce NMI
			;
HDLNMI		LD BC,BASMAIN2				; Carica in BC il valore 0x1A18 (L1A18 BASMAIN2)
			JP HDLNMI2					; Passa alla 0x19AE (L19AE HDLNMI2)

			; 
			; Dati caricati da routine BASIC di inizializzazione 
			; 	a partire da 0x4000 (VARINIT)
			;
SYSAREA		JP CKCHAR				; (4000)  vettore 0x4000 per RST 0x08 CKCHAR
			JP GETCH				; (4003)  vettore 0x4003 per RST 0x10 GETCH
			JP CPDEHL				; (4006)  vettore 0x4006 per RST 0x18 CPDEHL
			JP GETTYPE				; (4009)  vettore 0x4009 per RST 0x20 GETTYPE
			RET						; (400C)  vettore 0x400C per RST 0x28 VECSYS
			NOP						; 
			NOP						; 
			RET						; (400F)  vettore 0x400F per RST 0x30 ONLYRT2
			NOP						; 
			NOP						; 
			EI						; (4012)  vettore 0x4012 per RST 0x38 EIRET
			RET						; 	    
			NOP						; 
			.BYTE 0x01				; (4015) 01			TBVEC01 
			.DW	  INHWKB			; (4016) e3 03    	Funzione 1 in tabella TBVEC01 => 0x03E3 (L03E3 INHWKB)
			.BYTE 0x00, 0x00, 0x00	; (4018) 00 00 00
			.BYTE 0x4B, 0x49		; (401B) 4b 49
			.BYTE 0x07				; (401D) 07			TBVEC07 
			.DW	  IOSCR				; (401E) f5 03		Funzione 1 in tabella TBVEC07 => 0x03F5 (L03F5 IOSCR)
			.DW   VIDBASE			; (4020) 00 ec		SCRCURR
			.BYTE 0x00, 0x44, 0x4F	; (4022) 00 44 4f
			.BYTE 0x06				; (4025) 06			TBVEC06
			.DW   PRCHAR			; (4026) 9f 04		Funzione 1 in tabella TBVEC06 => 0x049F (L049F PRCHAR)
			.BYTE 0x00				; (4028) 00			LineFeed 00=NO
			.BYTE 0x00, 0x00		; (4029) 00 00
			.BYTE 0x50, 0x52, 0xC3	; (402B) 50 52 c3 
			.BYTE 0x00, 0x50, 0xC7	; (402E) 00 50 c7 
			.BYTE 0x00, 0x00		; (4031) 00 00
			;
			LD A,0x00				; (4033) (L4033 ZEROA)
			RET						; (4035) 
SZSYSAREA	EQU		$-SYSAREA
			; Fine dati

			;
			; Routine 0x0708 - ROUND
			;
ROUND		LD HL,HALF			; Carica in HL il valore 0x1380 (puntatore ad HALF)
								;   continua con la 0x070B (L070B ADDPHL)

			;
			; Routine 0x070B - ADDPHL - Somma valore puntato da (HL)
			;
ADDPHL		CALL PHL2BCDE			; Chiama la 0x09C2 (L09C2 PHL2BCDE)
			JR FPADD				; Passa alla 0x0716 (L0716 FPADD)

			;
			; Routine 0x0710 - SUBPHL  Sottrae FPREG dal valore puntato da HL
			;
SUBPHL		CALL PHL2BCDE			; Chiama la 0x09C2 (L09C2 PHL2BCDE)
									;   contrinua con 0x0713 (L0713 FPSUB)

			;
			; Routine 0x0713 - FPSUB  Sottrazione in virgola mobile
			;
FPSUB		CALL L0982				; Chiama la 0x0982 (L0982 INVSGN)
									;   continua con la 0x0716 (L0716 FPADD)

			;
			; Routine 0x0716 - FPADD  Somma in virgola mobile
			;
FPADD		LD A,B					; Copia B in A
			OR A					; Esegue OR di A
			RET Z					; Se zero, ritorna
			LD A,(FPEXP)			; Carica in A da memoria puntata (0x4124) FPEXP
			OR A					; Esegue OR di A
			JP Z,BCDE2FPR			; Se zero, passa a 0x09B4 (L09B4 BCDE2FPR)
			SUB B					; Sottrae B da A
			JR NC,L072F				; Se CY=0, passa a 0x072F
			CPL						; Complementa A
			INC A					; Incrementa A
			EX DE,HL				; Scambia DE ed HL
			CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)
			EX DE,HL				; Scambia DE ed HL
			CALL BCDE2FPR			; Chiama la 0x09B4 (L09B4 BCDE2FPR)
			POP BC					; Recupera BC dallo stack
			POP DE					; Recupera DE dallo stack
L072F		CP 0x19					; Compara A con il valore 0x19
			RET NC					; Se CY=0, ritorna
			PUSH AF					; Salva AF nello stack
			CALL SIGNS				; Chiama la 0x09DF (L09DF SIGNS)
			LD H,A					; Copia A in H
			POP AF					; Recupera AF dallo stack
			CALL L07D7				; Chiama la 0x07D7 (L07D7 SCALE)
			OR H					; Esegue OR di A con H
			LD HL,FPREG				; Carica in HL il valore 0x4121 FPREG
			JP P,L0754				; Se positivo, passa a 0x0754
			CALL L07B7				; Chiama la 0x07B7 (L07B7 SUM24)
			JP NC,ROUNDUP			; Se CY=0, passa a 0x0796 (L0796 ROUNDUP)
			INC HL					; Incrementa HL
			INC (HL)				; Incrementa memoria puntata da (HL)
			JP Z,OVERR				; Se zero, passa a 0x07B2 (L07B2 OVERR)
			LD L,0x01				; Carica in L il valore 0x01
			CALL L07EB				; Chiama la 0x07EB (L07EB SHRT1)
			JR ROUNDUP				; Passa alla 0x0796 (L0796 ROUNDUP)
			;
L0754		XOR A					; Azzera A
			SUB B					; Sottrae B da A
			LD B,A					; Copia A in B
			LD A,(HL)				; Carica in A da memoria puntata (HL)
			SBC A,E					; Sottrae E da A
			LD E,A					; Copia A in E
			INC HL					; Incrementa HL
			LD A,(HL)				; Incrementa memoria puntata da (HL)
			SBC A,D					; Sottrae D da A
			LD D,A					; Copia A in D
			INC HL					; Incrementa HL
			LD A,(HL)				; Carica in A da memoria puntata (HL)
			SBC A,C					; Sottrae C da A
			LD C,A					; Copia A in C
									;   continua con la 0x0762 (L0762 CONPOS)

			;
			; Routine 0x0762 - CONPOS
			;
CONPOS		CALL C,COMPL			; Chiama la 0x07C3 (L07C3 COMPL)
L0765		LD L,B					; Copia B in L
			LD H,E					; Copia E in H
			XOR A					; Azzera A
L0768		LD B,A					; Copia A in B
			LD A,C					; Copia C in A
			OR A					; Esegue OR di A
			JR NZ,PNORM				; Se diverso da zero, passa a 0x0785 (L0785 PNORM)
			LD C,D					; Copia D in C
			LD D,H					; Copia H in D
			LD H,L					; Copia L in H
			LD L,A					; Copia A in L
			LD A,B					; Copia B in A
			SUB 0x08				; Sottrae da A il valore 0x08
			CP 0xE0					; Compara A con il valore 0xE0
			JR NZ,L0768				; Se diverso da zero, passa a 0x0768 (L0768), ciclo
									;   altrimenti passa a 0x0778 (L0778 ZREXP)

			;
			; Routine 0x0778 - ZREXP  Azzera esponente di FPREG
			;
ZREXP		XOR A					; Azzera A
									;   continua con la 0x0779 (L0779 SAVAEXP)

			;
			; Routine 0x0779 - SAVAEXP  salva A in esponente di FPREG
			;    Input: A esponente
			;
SAVAEXP		LD (FPEXP),A			; Salva A in memoria puntata da (0x4124) FPEXP
			RET						; Ritorna

			;
			; Routine 0x077D - NORMAL
			;
NORMAL		DEC B					; Decrementa B
			ADD HL,HL				; Raddoppia HL
			LD A,D					; Copia D in A
			RLA						; Ruota A a sinistra di 1 bit
			LD D,A					; Copia A in D
			LD A,C					; Copia C in A
			ADC A,A					; Raddoppia A con CY
			LD C,A					; Copia A in C
									;   continua con la 0x0785 (L0785 PNORM)

			;
			; Routine 0x0785 - PNORM 
			;
PNORM		JP P,NORMAL				; Se positivo, passa a 0x077D (L077D NORMAL)
			LD A,B					; Copia B in A
			LD E,H					; Copia H in E
			LD B,L					; Copia L in B
			OR A					; Esegure OR di A
			JR Z,ROUNDUP				; Se zero, passa alla 0x0796 (L0796 ROUNDUP)
			LD HL,FPEXP				; Carica in HL il valore 0x4124 (puntatore a FPEXP)
			ADD A,(HL)				; Somma ad A memoria puntata da (HL)
			LD (HL),A				; Salva A in memoria puntata da (HL)
			JR NC,ZREXP				; Se CY=0, passa a 0x0778 (L0778 ZREXP)
			RET Z					; Se zero, ritorna
									;  altrimenti continua con la 0x0796 (L0796 ROUNDUP)

			;
			; Routine 0x0796 - ROUNDUP  Arrotonda in alto
			;
ROUNDUP		LD A,B					; Copia B in A
ROUNDUP2	LD HL,FPEXP				; Carica in HL il valore 0x4124 (puntatore a FPEXP)
			OR A					; Esegue OR di A
			CALL M,L07A8			; Se negativo, passa a 0x07A8
			LD B,(HL)				; Carica in B memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD A,(HL)				; Carica in A memoria puntata da (HL)
			AND 0x80				; Esegue AND di A con il valore 0x80
			XOR C					; Esegue XOR di A con C
			LD C,A					; Copia A in C
			JP BCDE2FPR				; Passa alla 0x09B4 (L09B4 BCDE2FPR)
			;
L07A8		INC E					; Incrementa E
			RET NZ					; Se diverso da zero, ritorna
			INC D					; Incrementa D
			RET NZ					; Se diverso da zero, ritorna
			INC C					; Incrementa C
			RET NZ					; Se diverso da zero, ritorna
			LD C,0x80				; Carica in C il valore 0x80
			INC (HL)				; Incrementa memoria puntata da (HL)
			RET NZ					; Se diverso da zero, ritorna
									;   altrimenti continua con 0x07B2 (L07B2 OVERR)

			;
			; Routine 0x07B2 - OVERR - Overflow Error
			;
OVERR		LD E,ECOD0A				; Carica in E il valore 0x0A (Codice errore Overflow)
			JP MSGERR				; Passa alla 0x19A2 (L19A2 MSGERR)

			;
			; Routine 0x07B7 - SUM24  Somma 24 bit tra CDE e memoria puntata da (HL)
			;   Input: HL puntatore a 24 bit in memoria
			;		   BCDE valore a 24 bit in CDE
			;
L07B7		LD A,(HL)				; Carica in A da memoria puntata da (HL)
			ADD A,E					; Somma E ad A
			LD E,A					; Copia A in E
			INC HL					; Incrementa HL
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			ADC A,D					; Somma D ad A con CY
			LD D,A					; Copia A in D
			INC HL					; Incrementa HL
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			ADC A,C					; Somma C ad A con CY
			LD C,A					; Copia A in C
			RET						; Ritorna

			;
			; Routine 0x07C3 - COMPL  Complementa risultato
			;
COMPL		LD HL,0x4125			; Carica in HL il valore 0x4125
			LD A,(HL)				; Carica in A memoria puntata da (HL)
			CPL						; Complementa A
			LD (HL),A				; Salva A in memoria puntata da (HL)
			XOR A					; Azzera A
			LD L,A					; Copia A in L
			SUB B					; Sottrae B da A
			LD B,A					; Copia A in B
			LD A,L					; Copia L in A
			SBC A,E					; Sottrae E da A con CY
			LD E,A					; Copia A in E
			LD A,L					; Copia L in A
			SBC A,D					; Sottrae D da A con CY
			LD D,A					; Copia A in D
			LD A,L					; Copia L in A
			SBC A,C					; Sottrae C da A con CY
			LD C,A					; Copia A in C
			RET						; Ritorna

			;
			; Routine 0x07D7 - SCALE Esegue shift di BCDE
			;   Input: A numero bit da shiftare
			;
L07D7		LD B,0x00				; Azzera B							; Clear underflow
L07D9		SUB 0x08				; Sottrae da A il valore 0x08		; 8 bits (a whole byte)?
			JR C,L07E4				; Se CY=1, passa a 0x07E4			; No - Shift right A bits
			LD B,E					; Copia E in B						; <- Shift
			LD E,D					; Copia D in E						; <- right
			LD D,C					; Copia C in D						; <- eight
			LD C,0x00				; Azzera C							; <- bits
			JR L07D9				; Passa a 0x07D9					; More bits to shift
			;
L07E4		ADD A,0x09				; Somma ad A il valore 0x09			; Adjust count
			LD L,A					; Copia A in L						; Save bits to shift
L07E7		XOR A					; Azzera A							; Flag for all done
			DEC L					; Decrementa L						; All shifting done?
			RET Z					; Se zero, ritorna					; Yes - Return
			LD A,C					; Copia C in A						; Get MSB
									;  continua con la 0x07EB (L07EB SHRT1)

			;
			; Routine 0x07EB - SHRT1  Shift del risultato a destra
			;
L07EB		RRA						; Ruota A a destra di 1 bit			; Shift it right
			LD C,A					; Copia A in C						; Re-save
			LD A,D					; Copia D in A						; Get NMSB
			RRA						; Ruota A a destra di 1 bit			; Shift right with last bit
			LD D,A					; Copia A in D						; Re-save it
			LD A,E					; Copia E in A						; Get LSB
			RRA						; Ruota A a destra di 1 bit			; Shift right with last bit
			LD E,A					; Copia A in E						; Re-save it
			LD A,B					; Copia B in A						; Get underflow
			RRA						; Ruota A a destra di 1 bit			; Shift right with last bit
			LD B,A					; Copia A in B						; Re-save underflow
			JR L07E7				; Passa a 0x07E7					; More bits to do

			;
			; Valori FP notevoli
			;
UNITY		.BYTE 0x00, 0x00, 0x00, 0x81	; UNITY 1.00000

			;
			; Tabella LOGTAB
			;
LOGTAB		.BYTE 0x03 						; LOGTAB (3 elementi)
			.BYTE 0xAA, 0x56, 0x19, 0x80	; 0.59898 
			.BYTE 0xF1, 0x22, 0x76, 0x80	; 0.96147
			.BYTE 0x45, 0xAA, 0x38, 0x82	; 2.88539

			; 
			; Routine 0x0809 - LOG
			;
LOG			CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)
			OR A					; Esegue OR di A
			JP PE,IFERR				; Se pe, passa alla 0x1E4A (L1E4A IFERR)
			LD HL,FPEXP				; Carica in HL il valore 0x4124 (puntatore a FPEXP)
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			LD BC,0x8035			; Carica in BC il valore 0x8035					; BCDE = SQR(1/2)
			LD DE,0x04F3			; Carica in DE il valore 0x04F3
			SUB B					; Sottrae B da A
			PUSH AF					; Salva AF nello stack
			LD (HL),B				; Salva B in memoria puntata da (HL)
			PUSH DE					; Salva DE nello stack
			PUSH BC					; Salva BC nello stack
			CALL FPADD				; Chiama la 0x0716 (L0716 FPADD)
			POP BC					; Recupera BC dallo stack
			POP DE					; Recupera DE dallo stack
			INC B					; Incrementa B
			CALL DIVBCDE				; Chiama la 0x08A2 (L08A2 DIVBCDE)
			LD HL,UNITY				; Carica in HL il valore 0x07F8 (Puntatore a UNITY)
			CALL SUBPHL				; Chiama la 0x0710 (L0710 SUBPHL)
			LD HL,LOGTAB			; Carica in HL il valore 0x07FC (puntatore a LOGTAB)
			CALL L149A				; Chiama la 0x149A (L149A SUMSER)
			LD BC,0x8080			; Carica in BC il valore 0x8080					; BCDE = -0.5
			LD DE,0x0000			; Carica in DE il valore 0x0000
			CALL FPADD				; Chiama la 0x0716 (L0716 FPADD)
			POP AF					; Recupera AF dallo stack
			CALL RSCALE				; Chiama la 0x0F89 (L0F89 RSCALE)
									;   continua con la 0x0841 (L0841 MULLN2)

			;
			; Routine 0x0841 - MULLN2 Moltiplica per ln(2)
			;
MULLN2		LD BC,0x8031			; Carica in BCDE il ln(2) 0x18723180
			LD DE,0x7218			;  e passa alla 0x0847 (L0847 FPMULT Moltiplica BCDE per FPREG)
			
			;
			; Routine 0x0847 - FPMULT  esegue operazione FPREG = FPREG * BCDE
			;
FPMULT		CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)					; Test sign of FPREG
			RET Z					; Se zero, ritorna									; Return zero if zero
			LD L,0x00				; Azzera L, flag addizione esponenti				; Flag add exponents
			CALL ADDEXP				; Chiama la 0x0914 (L0914 ADDEXP)					; Add exponents
			LD A,C					; Copia C in A 										; Get MSB of multiplier
			LD (MULMSB),A			; Copia A in memoria puntata da (0x414F) MULMSB		; Save MSB of multiplier
			EX DE,HL				; Scambia DE ed HL
			LD (MULLSB),HL			; Salva HL in memoria puntata da (0x4150) MULLSB	; Save rest of multiplier
			LD BC,0x0000			; Azzera BC											; Partial product (BCDE) = zero
			LD D,B					; Copia B in D
			LD E,B					; Copia B in E
			LD HL,0x0765			; Carica in HL il valore 0x0765						; Address of normalise BNORM
			PUSH HL					; Salva HL nello stack								; Save for return
			LD HL,0x0869			; Carica in HL il valore 0x0869						; Address of 8 bit multiply MULT8
			PUSH HL					; Salva HL nello stack								; Save for NMSB,MSB
			PUSH HL					; Salva HL nello stack								; 
			LD HL,FPREG				; Carica in HL il valore 0x4121 FPREG				; Point to number
L0869		LD A,(HL)				; Carica in A memoria puntata da (HL)				; Get LSB of number
			INC HL					; Incrementa HL										; Point to NMSB
			OR A					; Esegue OR di A									; Test LSB
			JR Z,REGSFT				; Se zero, passa a 0x0892 (L0892 REGSFT)			; Zero - shift to next byte
			;
			PUSH HL					; Salva HL nello stack								; Save address of number
			LD L,0x08				; Carica in L il valore 0x08						; 8 bits to multiply by
L0871		RRA  					; Shift a destra A di 1 bit							; Shift LSB right
			LD H,A					; Copia A in H										; Save LSB
			LD A,C					; Copia C in A										; Get MSB
			JR NC,L0881				; Se CY=0, passa a 0x0881							; Bit was zero - Don't add
			PUSH HL					; Salva HL nello stack								; Save LSB and count
			LD HL,(MULLSB)			; Carica in HL memoria puntata da (0x4150) MULLSB	; Get LSB and NMSB
			ADD HL,DE				; Somma DE ad HL									; Add NMSB and LSB
			EX DE,HL				; Scambia DE ed HL									; Leave sum in DE
			POP HL					; Recupera HL dallo stack							; Restore MSB and count
			LD A,(MULMSB)			; Carica in A memoria puntata da (0x414F) MULMSB	; Get MSB of multiplier
			ADC A,C					; Somma C ad A										; Add MSB
L0881		RRA 					; Shift a destra A di 1 bit							; Shift MSB right
			LD C,A					; Copia A in C										; Re-save MSB
			LD A,D					; Copia D in A										; Get NMSB
			RRA 					; Shift a destra A di 1 bit							; Shift NMSB right
			LD D,A					; Copia A in D										; Re-save NMSB
			LD A,E					; Copia E in A										; Get LSB
			RRA 					; Shift a destra A di 1 bit							; Shift LSB right
			LD E,A					; Copia A in E										; Re-save LSB
			LD A,B					; Copia B in A										; Get VLSB
			RRA 					; Shift a destra A di 1 bit							; Shift VLSB right
			LD B,A					; Copia A in B										; Re-save VLSB
			DEC L					; Decrementa L										; Count bits multiplied
			LD A,H					; Copia H in A										; Get LSB of multiplier
			JR NZ,L0871				; Se diverso da zero, passa a 0x0871				; More - Do it
L0890		POP HL					; Recupera HL dallo stack							; Restore address of number
			RET						; Ritorna
			
			;
			; Routine 0x0892 - REGSFT  Shift a sinistra il prodotto parziale
			;
REGSFT		LD B,E					; Copia E in B								; Shift A>C>D>E>B			
			LD E,D					; Copia D in E
			LD D,C					; Copia C in D
			LD C,A					; Copia A in C
			RET     				; Ritorna

			;
			; Routine 0x0897 - DIV10 
			;
L0897		CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)
			LD HL,FPTEN				; Carica in HL il valore 0x0DD8 (puntatore a FPTEN)
			CALL PHL2BCDEFP			; Chiama la 0x09B1 (L09B1 PHL2BCDEFP)
									;  continua con la 0x08A0 (L08A0 DIV)

			;
			; Routine L08A0 - DIV  Calcola FPREG = (BCDE nello stack) / FPREG
			;   Input: valore FP nello stack in BCDE
			;
DIV 		POP BC					; Recupera BC dallo stack					; Get number from stack
			POP DE					; Recupera DE dallo stack           	
									;   continua con 0x08A2 (L08A2 DIVBCDE)

			;
			; Routine L08A2 - DIVBCDE  Calcola FPREG = BCDE / FPREG
			;   Input: BCDE = divisore
			;		   FPREG = dividendo
			;
DIVBCDE		CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)							; Test sign of FPREG
			JP Z,DZERR				; Se zero, passa a 0x199A (L199A DZERR) 					; Error if division by zero
			LD L,0xFF				; Carica in L il valore 0xFF, flag sottrazione esponenti	; Flag subtract exponents (-1)
			CALL ADDEXP 			; Chiama la 0x0914 (L0914 ADDEXP)							; Subtract exponents
			INC (HL)				; Incrementa memoria puntata da (HL)						; Add 2 to exponent to adjust
			INC (HL)				; Incrementa memoria puntata da (HL)						                                    
			DEC HL					; Decrementa HL												; Point to MSB
			LD A,(HL)				; Carica in A memoria puntata da (HL)						; Get MSB of dividend
			LD (DIV3),A				; Salva A in memoria puntata da (0x4089) DIV3				; Save for subtraction
			DEC HL       			; Decrementa HL								               	
			LD A,(HL)				; Carica in A memoria puntata da (HL)						; Get NMSB of dividend
			LD (DIV2),A				; Salva A in memoria puntata da (0x4085) DIV2				; Save for subtraction
			DEC HL					; Decrementa HL
			LD A,(HL)				; Carica in A memoria puntata da (HL)						; Get MSB of dividend 
			LD (DIV1),A				; Salva A in memoria puntata da (0x4081) DIV1				; Save for subtraction
			LD B,C					; Copia C in B												; Get MSB
			EX DE,HL				; Scambia DE ed HL											; NMSB,LSB to HL
			XOR A					; Azzera A
			LD C,A					; Azzera C													; Clear MSB of quotient
			LD D,A       			; Azzera D    												; Clear NMSB of quotient
			LD E,A					; Azzera E                          						; Clear LSB of quotient
			LD (DIV4),A				; Salva A in memoria puntata da (0x498C) DIV4				; Clear overflow count
L08C7		PUSH HL					; Salva HL nello stack										; Save divisor
			PUSH BC					; Salva BC nello stacks
			LD A,L					; Copia L in A												; Get LSB of number
			CALL DIVSUP				; Chiama la 0x4080 (L4080 DIVSUP)							; Subt' divisor from dividend
			SBC A,0x00				; Sottrae da A il valore 0x00 e il CY						; Count for overflows
			CCF           			; Inverte CY														     				
			JR NC,L08D9				; Se CY=0, passa a 0x08D9									; Restore divisor if borrow
			LD (DIV4),A 			; Salva A in memoria puntata da (0x408C) DIV4				; Re-save overflow count 
			POP AF					; Recupera AF dallo stack									; Scrap divisor
			POP AF					; Recupera AF dallo stack									                      	
			SCF						; CY=1														; Set carry to
			.BYTE 0xD2				; Non esegue mai JP NC,0xE1C1  skip istruzioni POP BC e POP HL
									;   continua con la 0x08DB (L08DB)
L08D9		POP BC					; Recupera BC dallo stack									; Restore divisor
			POP HL					; Recupera HL dallo stack		
L08DB		LD A,C   				; Copia C in A												; Get MSB of quotient
			INC A					; Incrementa A
			DEC A					; Decrementa A												                  	
			RRA						; Ruota A da bit 0 a bit 7									; Bit 0 to bit 7
			JP M,ROUNDUP2			; Se negativo, passa a 0x0797 (L0797 ROUNDUP2)				; Done - Normalise result
			RLA						; Ruota A di 1 bit a sinistra								; Restore carry
			LD A,E					; Copia E in A												; Get LSB of quotient
			RLA						; Ruota A di 1 bit a sinistra								; Double it
			LD E,A					; Copia A in E												; Put it back
			LD A,D					; Copia D in A												; Get NMSB of quotient
			RLA						; Ruota A di 1 bit a sinistra								; Double it
			LD D,A					; Copia A in D												; Put it back
			LD A,C					; Copia C in A												; Get MSB of quotient
			RLA						; Ruota A di 1 bit a sinistra								; Double it
			LD C,A					; Copia A in C												; Put it back
			ADD HL,HL				; Raddoppia HL												; Double NMSB,LSB of divisor
			LD A,B					; Copia B in A												; Get MSB of divisor
			RLA						; Ruota A di 1 bit a sinistra								; Double it
			LD B,A     				; Copia A in B												; Put it back
			LD A,(DIV4)				; Carica in A memoria puntata da (0x408C) DIV4	 			; Get VLSB of quotient
			RLA						; Ruota A di 1 bit a sinistra								; Double it
			LD (DIV4),A				; Salva A in memoria puntata da (0x408C) DIV4				; Put it back
			LD A,C					; Copia C in A												; Get MSB of quotient
			OR D					; Esegue OR di A con D										; Merge NMSB
			OR E					; Esegue OR di A con E										; Merge LSB
			JR NZ,L08C7				; Se diverso da zero, passa a 0x08C7						; Not done - Keep dividing
			PUSH HL					; Salva HL nello stack										; Save divisor
			LD HL,FPEXP				; Carica in HL il valore 0x4124	(puntatore a FPEXP)			; Point to exponent FPEXP
			DEC (HL)				; Decrementa memoria puntata da (HL)						; Divide by 2
			POP HL					; Recupera HL dallo stack									; Restore divisor
			JR NZ,L08C7				; Se diverso da zero, passa a 0x08C7						; Ok - Keep going
			JP OVERR				; Passa a 0x07B2 (L07B2 OVERR)								; Overflow error

			;
			; Routine 0x0907
			;																						
L0907		LD A,0xFF				; Carica in A il valore 0xFF
			.BYTE 0x2E				; Esegue LD L,0xAF  skip istruzione XOR A
									;   continua con 0x090B (L090B)
L090A		XOR A 					; Azzera A
L090B		LD HL,0x412D			; Carica in HL il valore 0x412D
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			XOR (HL)				; Esegue XOR di A con memoria puntata da (HL)                      
			LD B,A					; Copia A in B                        
			LD L,0x00				; Azzera L
									;   continua con 0x0914 (L0914 ADDEXP)

			;
			; Routine 0x0914 - ADDEXP
			;   Input: L Flag operazione  0x00=somma  0xFF=sottrae
			;
ADDEXP		LD A,B					; Copia B in A										; Get exponent of dividend
			OR A					; Esegue OR di A                                    ; Test it
			JR Z,L0937				; Se zero, passa a 0x0937							; Zero - Result zero
			LD A,L					; Copia L in A										; Get add/subtract flag
			LD HL,FPEXP				; Carica in HL il valore 0x4124 (puntatore a FPEXP)	; Point to exponent
			XOR (HL)				; Esegue XOR di A con memoria puntata da (HL)		; Add or subtract it
			ADD A,B					; Somma B ad A										; Add the other exponent
			LD B,A					; Copia A in B                            			; Save new exponent
			RRA						; Ruota A a destra di 1 bit                			; Test exponent for overflow
			XOR B					; Esegue XOR di A con B
			LD A,B					; Copia B in A                          			; Get exponent
			JP P,L0936				; Se positivo, passa a 0x0936						; Positive - Test for overflow
			ADD A,0x80				; Somma ad A il valore 0x80							; Add excess 128
			LD (HL),A				; Salva A in memoria puntata da (HL)				; Save new exponent
			JP Z,L0890				; Se zero, passa a 0x0890							; Zero - Result zero
			CALL SIGNS				; Chiama la 0x09DF (L09DF SIGNS)					; Set MSBs and sign of result
			LD (HL),A				; Salva A in memoria puntata da (HL)				; Save new exponent
									;   continua con la 0x092F (L092F DECHL)

			;
			; Routine 0x092F - DECHL Decrementa HL
			;
L092F		DEC	HL					; Decrementa HL										; Point to MSB
			RET						; Ritorna     

			;
			; Routine 0x0931		
			;
L0931		CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)
			CPL						; Complementa A
			POP HL					; Recupera HL dallo stack
L0936		OR A					; Esegue OR di A
L0937		POP HL					; Recupera HL dallo stack
			JP P,ZREXP				; Se positivo, passa a 0x0778 (L0778 ZREXP)
			JP OVERR				; Passa a 0x07B2 (L07B2 OVERR)

			;
			; Routine 0x093E - MLSP10  Moltiplica per 10
			;
MLSP10		CALL FPR2BCDE			; Chiama la 0x09BF (L09BF FPR2BCDE)						; Move FPREG to BCDE
			LD A,B					; Copia B in A											; Get exponent
			OR A					; Esegue OR di A										; Is it zero?
			RET Z					; Se zero, ritorna										; Yes - Result is zero
			ADD A,0x02				; Somma ad A il valore 0x02								; Multiply by 4
			JP C,OVERR				; Se CY=1, passa a 0x07B2 (L07B2 OVERR)					; Overflow - ?OV Error
			LD B,A					; Copia A in B											; Re-save exponent
			CALL FPADD				; Chiama la 0x0716 (L0716 FPADD)						; Add BCDE to FPREG (Times 5)
			LD HL,FPEXP				; Carica in HL il valore 0x4124 (puntatore a FPEXP)		; Point to exponent
			INC (HL)				; Incrementa memoria puntata da (HL)					; Double number (Times 10)
			RET NZ					; Se diverso da zero, ritorna							; Ok - Return
			JP OVERR				; Passa alla 0x07B2 (L07B2 OVERR)						; Overflow error

			;
			; Routine 0x0955 - TSTSGN Test segno FPREG
			;   Output: A -1, 0, 1
			;
TSTSGN		LD A,(FPEXP)			; Carica in A memoria puntata da (0x4124) FPEXP			; Get sign of FPREG
			OR A					; Esegue OR di A
			RET Z					; Se zero, ritorna										; RETurn if number is zero
			LD A,(FPREGMSB)			; Carica in A memoria puntata da (0x4123) FPREGMSB		; Get MSB of FPREG
			.BYTE 0xFE																		; Test sign
L095E		CPL						; Complementa A											; Invert sign
									;   continua con la 0x095F (L095F TSTSGNA)

			; 
			; Routine 0x095F - TSTSGNA  Test segno di A
			;  Input:  A
			;  Output: A 0x01 pos, 0xFF neg
			;
TSTSGNA		RLA 					; Ruota a sinistra A di 1 bit							; Sign bit to carry
									;   continua con la 0x0960 (L0960 FLGDIF)

			; 
			; Routine 0x0960 - FLGDIF
			;
FLGDIF		SBC A,A					; Sottrae A da A										; Carry to all bits of A
			RET NZ					; Se diverso da zero, ritorna							; Return -1 if negative
			INC A					; Incrementa A											; Bump to +1
			RET     				; Ritorna												; Positive - Return +1
			
			;
			; Routine 0x0964 - FLGREL
			;   Input: A  
			;
FLGREL		LD B,0x88				; Carica in B il valore 0x88 (esponente)				; 8 bit integer in exponent
			LD DE,0x0000			; Azzera DE												; Zero NMSB and LSB
									;  continua con la 0x0969 (L0969 ?)

			;
			; Routine 0x0969
			;   Input: A
			;		   B esponente
			;
L0969		LD HL,FPEXP				; Carica in HL il valore 0x4124 (puntatore a FPEXP)		; Point to exponent
			LD C,A					; Copia A in C											; CDE = MSB,NMSB and LSB
			LD (HL),B				; Salva B in memoria puntata da (HL)					; Save exponent
			LD B,0x00				; Azzera B												; CDE = integer to normalise
			INC HL					; Incrementa HL											; Point to sign of result
			LD (HL),0x80			; Salva il valore 0x80 in memoria puntata da (HL)		; Set sign of result
			RLA						; Ruota A a sinistra di 1 bit							; Carry = sign of integer
			JP CONPOS				; Passa a 0x0762 (L0762 CONPOS)							; Set sign of result

			;
			; Routine 0x0977 - ABS
			;
ABS			CALL L0994				; Chiama la 0x0994 (L0994 TSTSGNNUM)
			RET P					; Se positivo, ritorna					;
									;   altrimenti continua con la 0x097B (L097B INVSGN)
			;
			; Routine 0x097B - INVSGN  Inverte segno FPREG
			;
L097B		RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			JP M,L0C5B				; Se negativo, passa a 0x0C5B (L0C5B INVSGINT) (negativo, tipo int)
			JP Z,TMERR				; Se zero, passa a 0x0AF6 (L0AF6 TMERR) (tipo stringa)
									;   altrimenti continua con la 0x0982 (L0982 INVSGN) (tipo sng/dbl)

			;
			; Routine 0x0982 - INVSGN  Inverte segno valore FP in FPREG
			;
L0982		LD HL,FPREGMSB			; Carica in HL il valore 0x4123 (puntatore a FPREGMSB)
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			XOR 0x80				; Esegue XOR di A con 0x80 (inverte bit7, segno FP)
			LD (HL),A				; Salva A in memoria puntata da (HL)
			RET						; Ritorna     

			;
			; Routine 0x098A - SGN
			;
SGN			CALL L0994				; Chiama la 0x0994 (L0994 TSTSGNNUM)
									;   continua con la 0x098D (L098D MVAS2FPR)

			;
			; Routine 0x098D - MVAS2FPR  Salva byte A in FPREG
			;   Input: A valore byte con segno da salvare in FPREG
			;
MVAS2FPR	LD L,A					; Copia A in L
			RLA						; Ruota A di 1 bit a sinistra
			SBC A,A					; Sottrae A da A con CY
			LD H,A					; Copia A in H
			JP MVHL2FPR				; Passa a 0x0A9A (L0A9A MVHL2FPR)

			;
			; Routine 0x0994 - TSTSGNNUM  Controlla segno valori numerici
			;
L0994 		RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			JP Z,TMERR				; Se zero, passa a 0x0AF6 (L0AF6 TMERR) (errore, tipo stringa)
			JP P,TSTSGN				; Se positivo, passa alla 0x0955 (L0955 TSTSGN) (tipo sng/dbl)
			LD HL,(FPREG)			; Carica in HL da memoria puntata da (0x4121) (valore intero da FPREG)
									;   continua con la 0x099E (L099E ?)
			
			;
			; Routine 0x099E
			;
L099E		LD A,H					; Copia H in A
			OR L					; Esegue OR di A con L
			RET Z					; Se zero, ritorna (valore positivo)
			LD A,H					; Copia H in A 
			JR TSTSGNA				; Passa a 0x095F (0x095F TSTSGNA)
			
			;
			; Routine 0x09A4 - FPRONSTK
			;
FPRONSTK		EX DE,HL				; Scambia DE ed HL										; Save code string address
			LD HL,(FPREG)			; Carica HL da memoria puntata da (0x4121) FPREG		; LSB,NLSB of FPREG
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)				; Stack them,get return
			PUSH HL					; Salva HL nello stack									; Re-save return
			LD HL,(FPREGMSB)			; Carica HL da memoria puntata da (0x4123) FPREGMSB	; MSB and exponent of FPREG
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)				; Stack them,get return
			PUSH HL					; Salva HL nello stack									; Re-save return
			EX DE,HL				; Scambia DE ed HL										; Restore code string address
			RET						; Ritorna     

			;
			; Routine 0x09B1 - PHL2BCDEFP Carica (HL) in BCDE e in FPREG
			;
PHL2BCDEFP	CALL PHL2BCDE			; Chiama la 0x09C2 (L09C2 PHL2BCDE)
									;  continua con la 0x09B4 (L09B4 BCDE2FPR)

			;
			; Routine 0x09B4 - BCDE2FPR Salva BCDE in FPREG
			;
BCDE2FPR 	EX DE,HL				; Scambia DE ed HL
			LD (FPREG),HL			; Salva HL in memoria puntata da (0x4121) FPREG
			LD H,B					; Copia B in H
			LD L,C					; Copia C in L
			LD (FPREGMSB),HL		; Salva HL in memoria puntata da (0x4123) FPREGMSB
			EX DE,HL				; Scambia DE ed HL
			RET     				; Ritorna

			;
			; Routine 0x09BF - FPR2BCDE Carica FPREG in BCDE
			;
FPR2BCDE	LD HL,FPREG				; Carica in HL il valore 0x4121 FPREG

			;
			; Routine 0x09C2 - PHL2BCDE Carica (HL) in BCDE
			;   Input: HL puntatore a valore FP
			;
PHL2BCDE	LD E,(HL)				; Carica in E da memoria puntata da (HL)
			INC HL					; Incrementa HL
									;   continua con la 0x09C4 (L09C4 PHL2BCD0)

			;
			; Routine 0x09C4 - PHL2BCD0  Carica (HL) in BCD0
			;   Input: HL puntatore a valore FP
			;
PHL2BCD0	LD D,(HL)				; Carica in D da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
									;   continua con la 0x09C9 (L09C9 INCHL)

			;
			; Routine 0x09C9 - INCHL Incrementa HL
			;
INCHL		INC HL					; Incrementa HL
			RET     				; Ritorna

			;
			; Routine 0x09CB - CPYFPREGHL  Copia FPREG in memoria puntata da (HL)
			;   Input: HL = puntatore a destinazione
			;
CPYFPREGHL	LD DE,FPREG				; Carica in DE il valore 0x4121 (puntatore a FPREG)		; Point to FPREG
			LD B,0x04				; Carica in B il valore 0x04							; 4 bytes to move
			JR CPYMEM				; Passa alla 0x09D7 (L09D7 CPYMEM)						

			;
			; Routine 0x09D2 - CPYVHLDE  Copia variabile in memoria da (HL) in (DE)
			;   Input: HL = puntatore a variabile sorgente
			;          DE = puntatore a destinazione
			;          (TYPE) -> B = numero byte copiati (TYPE 2, 3, 4, 8)
			;
CPYVHLDE	EX DE,HL				; Scambia DE ed HL
									;   continua con la 0x09D3 (L09D3 CPYVDEHL)
																									
			;																						
			; Routine 0x09D3 - CPYVDEHL  Copia variabile in memoria da (DE) in (HL)
			;   Input: DE = puntatore a variabile sorgente
			;          HL = puntatore a destinazione
			;          (TYPE) -> B = numero byte copiati (TYPE 2, 3, 4, 8)
			;
CPYVDEHL	LD A,(TYPE)				; Carica in A da memoria puntata da (0x40AF) TYPE
			LD B,A					; Copia A in B
									;   continua con 0x09D7 (L09D7 CPYMEM)

			;																						
			; Routine 0x09D7 - CPYMEM  Copia blocco di memoria da (DE) in (HL)									
			;   Input: DE = puntatore a memoria sorgente																
			;          HL = puntatore a memoria destinazione 
			;          B  = numero byte copiati 
			;
CPYMEM		LD A,(DE)				; Carica in A da memoria puntata da (DE)
			LD (HL),A				; Salva A in memoria puntata da (HL)	
			INC DE					; Incrementa DE							
			INC HL					; Incrementa HL							
			DEC B					; Decrementa B							
			JR NZ,CPYMEM			; Se diverso da zero, passa a 0x09D7 (L09D7 CPYMEM)
			RET     				; Ritorna								

			;
			; Routine 0x09DF - SIGNS
			;
SIGNS		LD HL,FPREGMSB			; Carica in HL il valore 0x4123 (puntatore a FPREGMSB)	; Point to MSB of FPREG
			LD A,(HL)				; Carica in A da memoria puntata da (HL)				; Get MSB
			RLCA					; Ruota A a sinistra di 1 bit							; Old sign to carry
			SCF						; CY=1													; Set MSBit
			RRA						; Ruota A a destra di 1 bit								; Set MSBit of MSB
			LD (HL),A				; Salva A in memoria puntata da (HL)					; Save new MSB
			CCF						; Inverte CY											; Complement sign
			RRA						; Ruota A a destra di 1 bit								; Old sign to carry
			INC HL					; Incrementa HL
			INC HL					; Incrementa HL
			LD (HL),A				; Salva A in memoria puntata da (HL)					; Set sign of result
			LD A,C					; Copia C in A											; Get MSB
			RLCA					; Ruota A a sinistra di 1 bit							; Old sign to carry
			SCF						; CY=1													; Set MSBit
			RRA						; Ruota A a destra di 1 bit								; Set MSBit of MSB
			LD C,A					; Copia C in A											; Save MSB
			RRA						; Ruota A a destra di 1 bit
			XOR (HL)				; Esegue XOR di A con memoria puntata da (HL)			; New sign of result
			RET						; Ritorna

			;
			; Routine 0x09F4 - MVTMPFPS  Copia variabile da (0x4127) TMP? a (0x4121/0x411D) FPREG/STR
			;
L09F4		LD HL,UNK05				; Carica in HL il valore 0x4127 (puntatore a UNK05)
									;   continua con la 0x09F7 (L09F7 ?)

			;
			; Routine 0x09F7 
			;   Input: HL
			;
L09F7		LD DE,CPYVHLDE			; Carica in DE il valore 0x09D2 (punta alla 0x09D2 CPYVHLDE)
			JR L0A02				; Passa alla 0x0A02 (L0A02 MVCMN)
			
			;
			; Routine 0x09FC - MVFPSTMP  Copia variabile da (0x4121/0x411D) FPREG/STR a (0x4127) TMP?
			;
L09FC		LD HL,UNK05				; Carica in HL il valore 0x4127 (puntatore a UNK05)
			LD DE,CPYVDEHL			; Carica in DE il valore 0x09D3 (punta alla L09D3 CPYVDEHL)
									;  continua con la 0x0A02 (L0A02 MVCMN)

			;
			; Routine 0x0A02 - MVCMN  Parte comune routine MVTMPFPS/MVFPSTMP
			;
L0A02		PUSH DE					; Salva DE nello stack (puntatore a routine CPYVHLDE/CPYVDEHL)
L0A03		LD DE,FPREG				; Carica in DE il valore 0x4121 (puntatore a FPREG)
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			RET C					; Se CY=1, ritorna, copiando variabile numerica
			LD DE,TDBL1				; Carica in DE il valore 0x411D (puntatore a TDBL1)
			RET						; Ritorna, copiando variabile stringa

			;
			; Routine 0x0A0C - CMPNUM Compara FPREG con BCDE
			;
CMPNUM 		LD A,B					; Copia B in A											; Get exponent of number
			OR A					; Eseguer OR di A
			JP Z,TSTSGN				; Se zero, passa alla 0x0955 (L0955 TSTSGN)				; Zero - Test sign of FPREG
			LD HL,0x095E			; Carica in HL il valore 0x095E							; Return relation routine
			PUSH HL					; Salva HL nello stack									; Save for return
			CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)						; Test sign of FPREG
			LD A,C					; Copia C in A											; Get MSB of number
			RET Z					; Se zero, ritorna										; FPREG zero - Number's MSB
			LD HL,FPREGMSB			; Carica in HL il valore 0x4123	(puntatore a FPREGMSB)	; MSB of FPREG
			XOR (HL)				; Esegue XOR di A e memoria puntata da (HL)				; Combine signs
			LD A,C					; Copia C in A											; Get MSB of number
			RET M					; Se negativo, ritorna									; Exit if signs different
			CALL L0A26				; Chiama la 0x0A26 (L0A26 CMPFP)						; Compare FP numbers
L0A23		RRA     				; Ruota a destra A di 1 bit								; Get carry to sign
			XOR C					; Esegue XOR di A con C									; Combine with MSB of number
			RET						; Ritorna

			;
			; Routine 0x0A26 - CMPFP Compara valori FP, BCDE e puntato da (HL) 
			;
L0A26		INC HL					; Incrementa HL								; Point to exponent
			LD A,B					; Carica B in A								; Get exponent
			CP (HL)					; Compara A con memoria puntata da (HL)		; Compare exponents
			RET NZ					; Se diverso, ritorna						; Different
			DEC HL					; Decrementa HL								; Point to MBS
			LD A,C					; Copia C in A								; Get MSB
			CP (HL)					; Compara A con memoria puntata da (HL)		; Compare MSBs
			RET NZ					; Se diverso, ritorna						; Different
			DEC HL					; Decrementa HL								; Point to NMSB
			LD A,D					; Copia D in A								; Get NMSB
			CP (HL)					; Compara A con memoria puntata da (HL)		; Compare NMSBs
			RET NZ					; Se diverso, ritorna						; Different
			DEC HL					; Decrementa HL								; Point to LSB
			LD A,E					; Copia E in A								; Get LSB
			SUB (HL)				; Compara A con memoria puntata da (HL)		; Compare LSBs
			RET NZ					; Se diverso, ritorna						; Different
			POP HL					; Recupera HL dallo stack					; Drop RETurn
			POP HL					; Recupera HL dallo stack					; Drop another RETurn
			RET						; Ritorna

			;
			; Routine 0x0A39
			;
L0A39		LD A,D					; Copia D in A
			XOR H					; Esegue XOR di A con H
			LD A,H					; Copia H in A
			JP M,TSTSGNA			; Passa a 0x095F (L095F TSTSGNA)
			CP D					; Compara A con D
			JP NZ,FLGDIF			; Se diverso da zero, passa a 0x0960 (L0960 FLGDIF)
			LD A,L					; Copia L in A
			SUB E					; Sottrae E da A
			JP NZ,FLGDIF			; Se diverso da zero, passa a 0x0960 (L0960 FLGDIF)
			RET						; Ritorna   

			;
			; Routine 0x0A49
			;
L0A49		LD HL,UNK05				; Carica in HL il valore 0x4127 (puntatore a UNK05)
			CALL CPYVDEHL				; Chiama la 0x09D3 (L09D3 CPYVDEHL)
L0A4F		LD DE,0x412E			; Carica in DE il valore 0x412E (puntatore a ?)
			LD A,(DE)				; Carica in A da memoria puntata da (DE)
			OR A					; Esegue OR di A
			JP Z,TSTSGN				; Se zero, passa alla 0x0955 (L0955 TSTSGN)
			LD HL,0x095E			; Carica in HL il valore 0x095E
			PUSH HL					; Salva HL nello stack
			CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)
			DEC DE					; Decrementa DE
			LD A,(DE)				; Carica in A da memoria puntata da (DE)
			LD C,A					; Copia A in C
			RET Z					; Se zero, ritorna
			LD HL,0x4123			; Carica in HL il valore 0x4123 (puntatore a FPREGMSB)
			XOR (HL)				; Esegue XOR di A con memoria puntata da (HL)
			LD A,C					; Copia C in A
			RET M					; Se negativo, ritorna
			INC DE					; Incrementa DE
			INC HL					; Incrementa HL
			LD B,0x08				; Carica in B il valore 0x08
L0A6C		LD A,(DE)				; Carica in A da memoria puntata da (DE)
			SUB (HL)				; Sottrae da A memoria puntata da (HL)
			JP NZ,L0A23				; Se diverso da zero, passa alla 0x0A23
			DEC DE					; Decrementa DE
			DEC HL					; Decrementa HL
			DEC B					; Decrementa B
			JR NZ,L0A6C				; Se diverso da zero, passa alla 0x0A6C
			POP BC					; Recupera BC dallo stack
			RET						; Ritorna

			;
			; Routine 0x0A78
			;					
L0A78		CALL L0A4F				; Chiama la 0x0A4F (L0A4F ?)
			JP NZ,L095E				; Se diverso da zero, passa a 0x095E (L095E ?)
			RET						; Ritorna

			;
			; Routine 0x0A7F - CINT  Converte in intero
			;
CINT		RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			LD HL,(FPREG)			; Carica in HL da memoria puntata da (0x4121) FPREG
			RET M					; Se negativo, ritorna
			JP Z,TMERR				; Se zero, passa a 0x0AF6 (L0AF6 TMERR)
			CALL NC,L0AB9			; Se CY=0, chiama la 0x0AB9 (L0AB9 ?)
			LD HL,OVERR				; Carica in HL il valore 0x07B2 (L07B2 OVERR)
			PUSH HL					; Salva HL nello stack
L0A8E		LD A,(FPEXP)			; Carica in A memoria puntata da (0x4124) FPEXP
			CP 0x90					; Compara A con il valore 0x90
			JR NC,CMPM32K			; Se CY=0, passa a 0x0AA3 (L0AA3 CMPM32K)
			CALL FP2INT				; Chiama la 0x0AFB (L0AFB FP2INT)
			EX DE,HL				; Scambia DE ed HL
									;
MVI2FPREG	POP DE					; Recupera DE dallo stack
									;  continua con 0x0A9A (L0A9A MVHL2FPR)
			;
			; Routine 0x0A9A - MVHL2FPR  Salva intero HL in FPREG
			;   Input: HL valore intero da salvare in FPREG
			;
MVHL2FPR	LD (FPREG),HL			; Salva HL in memoria puntata da (0x4121) FPREG
			LD A,0x02				; Carica in A il valore 0x02 (Tipo intero)
									;   continua con la 0x0A9F (L0A9F SAVTYPE)

			;
			; Routine 0x0A9F - SAVTYPE  Salva in memoria il tipo di dato 
			;   Input: A tipo dato (0x02 Int, 0x03 Str, 0x04 Sng, 0x08 Dbl)
			;
SAVTYPE		LD (TYPE),A				; Salva A in memoria puntata da (0x40AF) TYPE
			RET     				; Ritorna
			
			;
			; Routine 0x0AA3 - CMPM32K  Compara numero con -32768 e salva 0x8000 in FPREG
			;
CMPM32K		LD BC,0x9080			; Carica in BC il valore 0x9080					; BCDE = -32768
			LD DE,0x0000			; Carica in DE il valore 0x0000
			CALL CMPNUM				; Chiama la 0x0A0C (L0A0C CMPNUM), compara FPREG con -32768
			RET NZ					; Se diverso da zero, ritorna
			LD H,C					; Copia C in H
			LD L,D					; Copia D in L, per ottenere HL=0x8000
			JR MVI2FPREG			; Passa a 0x0A99 (L0A99 MVI2FPREG)

			;
			; Routine 0x0AB1 - CSNG
			;
CSNG		RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			RET PO					; Se PV=1, ritorna
			JP M,L0ACC				; Se negativo, passa a 0x0ACC
			JP Z,TMERR				; Se zero, passa a 0x0AF6 (L0AF6 TMERR)
L0AB9		CALL FPR2BCDE			; Chiama la 0x09BF (L09BF FPR2BCDE)
			CALL SVSNG				; Chiama la 0x0AEF (L0AEF SVSNG)
			LD A,B					; Copia B in A
			OR A					; Esegue OR di A
			RET Z					; Se zero, ritorna
			CALL SIGNS				; Chiama la 0x09DF (L09DF SIGNS)
			LD HL,TDBL2+1			; Carica in HL il valore 0x4120 (puntatore a TDBL2+1)
			LD B,(HL)				; Caroca in B memoria puntata da (HL)
			JP ROUNDUP				; Passa a 0x0796 (L0796 ROUNDUP)


			;
			; Routine 0x0ACC
			;
L0ACC		LD HL,(FPREG)			; Carica in HL da memoria puntata (0x4121) FPREG
									;   continua con la 0x0ACF (0x0ACF ?)

			;
			; Routine 0x0ACF
			;   Input: HL
			;
L0ACF		CALL SVSNG				; Chiama la 0x0AEF (L0AEF SVSNG)
			LD A,H					; Copia H in A
			LD D,L					; Copia L in D
			LD E,0x00				; Azzera E
			LD B,0x90				; Carica in B il valore 0x90
			JP L0969				; Passa alla 0x0969 (L0969 ?)

			;
			; Routine 0x0ADB - CDBL
			;
CDBL		RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			RET NC					; Se CY=0, ritorna
			JP Z,TMERR				; Se zero, passa a 0x0AF6 (L0AF6 TMERR)
			CALL M,L0ACC			; Se negativo, passa a 0x0ACC
									;   continua con la 0x0AE3 (L0AE3 ?)

			;
			; Routine 0x0AE3
			;
L0AE3		LD HL,0x0000			; Azzera HL
			LD (TDBL1),HL			; Salva HL in memoria puntata da (0x411D) TDBL1
			LD (TDBL2),HL			; Salva HL in memoria puntata da (0x411F) TDBL2

			; 
			; Routine 0x0AEC - SVDBL  Salva in memoria il tipo dato Double
			;
L0AEC		LD A,0x08				; Carica in A il valore 0x08 (tipo double)
			.BYTE 0x01				; Skip prossima istruzione
									;   continua con la 0x0AF1 (L0AF1 > L0A9F SAVTYP)

			; 
			; Routine 0x0AEF - SVSNG  Salva in memoria il tipo dato Single
			;
SVSNG		LD A,0x04				; Carica in A il valore 0x04 (tipo single)
L0AF1		JP SAVTYPE				; Passa alla 0x0A9F (L0A9F SAVTYPE)
			
			;
			; Routine 0x0AF4 - TSTSTR  Test stringa
			;			
TSTSTR		RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			RET Z					; Se zero, ritorna (stringa)
									;   altrimenti passa a 0x0AF6 (L0AF6 TMERR)

			;
			; Routine 0x0AF6 - TMERR  Type Mismatch Error
			;
TMERR 		LD E,ECOD18				; Carica in E il valore 0x18 (codice errore Type Mismatch Error)
			JP MSGERR				; Passa a 0x19A2 (L19A2 MSGERR)
			
			;
			; Routine 0x0AFB - FP2INT Converte FP in intero
			;
FP2INT		LD B,A					; Copia A in B									; <- Move
			LD C,A					; Copia A in C									; <- exponent
			LD D,A					; Copia A in D									; <- to all
			LD E,A					; Copia A in E									; <- bits
			OR A					; Esegue OR di A								; Test exponent
			RET Z					; Se zero, ritorna								; Zero - Return zero
			PUSH HL					; Salva HL nello stack							; Save pointer to number
			CALL FPR2BCDE			; Chiama la 0x09BF (L09BF FPR2BCDE)				; Move FPREG to BCDE
			CALL SIGNS				; Chiama la 0x09DF (L09DF SIGNS)				; Set MSBs & sign of result
			XOR (HL)				; Esegue XOR di A con memoria puntata da (HL)	; Combine with sign of FPREG
			LD H,A					; Copia A in H									; Save combined signs
			CALL M,L0B1F			; Se negativo, chiama la 0x0B1F (L0B1F DCBCDE)	; Negative - Decrement BCDE
			LD A,0x98				; Carica in A il valore 0x98					; 24 bits
			SUB B					; Sottrae B da A								; Bits to shift
			CALL L07D7				; Chiama la 0x07D7 (L07D7 SCALE)				; Shift BCDE
			LD A,H					; Copia H in A									; Get combined sign
			RLA     				; Ruota A a sinistra di 1 bit					; Sign to carry
			CALL C,L07A8			; Se CY=1, chiama la 0x07A8 (L07A8 FPROND)		; Negative - Round number up
			LD B,0x00				; Azzera B										; Zero exponent
			CALL C,COMPL			; Se CY=1, chiama la 0x07C3 (L07C3 COMPL)		; If negative make positive
			POP HL					; Recupera HL dallo stack						; Restore pointer to number
			RET						; Ritorna

			;
			; Routine 0x0B1F - DCBCDE Decrementa BCDE
			; 
L0B1F		DEC DE					; Decrementa DE									; Decrement BCDE
			LD A,D					; Copia D in A									; Test LSBs
			AND E					; Esegue AND di A con E
			INC A					; Incrementa A
			RET NZ					; Se diverso da zero, ritorna					; Exit if LSBs not FFFF
L0B24		DEC BC					; Decrementa BC									; Decrement MSBs
			RET						; Ritorna  

			;
			; Routine 0x0B26 - FIX
			;
FIX			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			RET M					; Se negativo, ritorna
			CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)
			JP P,INT				; Se positivo, passa a 0x0B37 (L0B37 INT)
			CALL L0982				; Chiama la 0x0982 (L0982 INVSGN)
			CALL INT				; Chiama la 0x0B37 (L0B37 INT)
			JP L097B				; Passa alla 0x097B (L097B INVSGN)
			
			;
			; Routine 0x0B37 - INT
			;
INT			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			RET M					; Se negativo, ritorna
			JR NC,L0B59				; Se CY=0, passa a 0x0B59
			JR Z,TMERR				; Se zero, passa a 0x0AF6 (L0AF6 TMERR)
			CALL L0A8E				; Chiama la 0x0A8E (L0A8E ?)
									;   continua con la 0x0B40 (L0B40 ?)
			;
			; Routine 0x0B40
			;		
L0B40		LD HL,FPEXP				; Carica in HL il valore 0x4124 (puntatore a FPEXP)
			LD A,(HL)				; Carica in A memoria puntata da (HL)
			CP 0x98					; Compara A con il valore 0x98
			LD A,(FPREG)			; Carica in A da memoria puntata da (0x4121)
			RET NC					; Se CY=0, ritorna
			LD A,(HL)				; Carica in A memoria puntata da (HL)
			CALL FP2INT				; Chiama la 0x0AFB (L0AFB FP2INT)
			LD (HL),0x98			; Salva il valore 0x98 in memoria puntata da (HL)
			LD A,E					; Copia E in A
			PUSH AF					; Salva AF nello stack
			LD A,C					; Copia C in A
			RLA     				; Ruota A di 1 bit a sinistra
			CALL CONPOS				; Chiama la 0x0762 (L0762 CONPOS)
			POP AF					; Recupera AF dallo stack
			RET						; Ritorna    

			;
			; Routine 0x0B59 
			;
L0B59		LD HL,FPEXP				; Carica in HL il valore 0x4124 (puntatore a FPEXP)
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
L0B5D		CP 0x90					; Compara A con il valore 0x90
			JP C,CINT				; Se CY=1, passa alla 0x0A7F (L0A7F CINT)
			JR NZ,L0B78				; Se diverso da zero, passa a 0x0B78
			LD C,A					; Copia A in C
			DEC HL					; Decrementa HL
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			XOR 0x80				; Esegue XOR di A con il valore 0x80
			LD B,0x06				; Carica in B il valore 0x06
L0B6B		DEC HL					; Decrementa HL
			OR (HL)					; Esegue OR di A con memoria puntata da (HL)
			DEC B					; Decrementa B
			JR NZ,L0B6B				; Se zero, passa a 0x0B6B
			OR A					; Esegue OR di A
			LD HL,0x8000			; Carica in HL il valore 0x8000
			JP Z,MVHL2FPR			; Se zero, passa alla 0x0A9A (L0A9A MVHL2FPR)
			LD A,C					; Copia C in A
L0B78		CP 0xB8					; Compara A con il valore 0xB8
			RET NC					; Se CY=0, ritorna
L0B7B		PUSH AF					; Salva AF nello stack
			CALL FPR2BCDE			; Chiama la 0x09BF (L09BF FPR2BCDE)
			CALL SIGNS				; Chiama la 0x09DF (L09DF SIGNS)
			XOR (HL)				; Esegue XOR di A con memoria puntata da (HL)
			DEC HL					; Decrementa HL
			LD (HL),0xB8			; Salva il valore 0xB8 in memoria puntata da (HL)
			PUSH AF					; Salva AF nello stack
			CALL M,L0BA0			; Se negativo, chiama la 0x0BA0 (L0BA0 ?)
			LD HL,FPREGMSB			; Carica in HL il valore 0x4123 (puntatore a FPREGMSB)
			LD A,0xB8				; Carica in A il valore 0xB8
			SUB B					; Sottrae B da A
			CALL L0D69				; Chiama la 0x0D69 (L0D69 ?)
			POP AF					; Recupera AF dallo stack
			CALL M,L0D20			; Se negativo, chiama la 0x0D20 (L0D20 ?)
			XOR A					; Azzera A
			LD (0x411C),A			; Salva A in memoria puntata da (0x411C)
			POP AF					; Recupera AF dallo stack
			RET NC					; Se CY=0, ritorna
			JP L0CD8				; Passa alla 0x0CD8 (L0CD8 ?)

			;
			; Routine 0x0BA0
			;
L0BA0		LD HL,TDBL1				; Carica in HL il valore 0x411D (puntatore a TDBL1)
L0BA3		LD A,(HL)				; Carica in A da memoria puntata da (HL)
			DEC (HL)				; Decrementa memoria puntata da (HL)
			OR A					; Esegue OR di A 
			INC HL					; Incrementa HL
			JR Z,L0BA3				; Se zero, passa a 0x0BA3
			RET						; Ritorna

			;
			; Routine 0x0BAA
			;
L0BAA		PUSH HL					; Salva HL nello stack
			LD HL,0x0000			; Azzera HL
			LD A,B					; Copia B in A
			OR C					; Esegue OR di A con C
			JR Z,L0BC4				; Se zero, passa a 0x0BC4
			LD A,0x10				; Carica in A il valore 0x10
L0BB4		ADD HL,HL				; Raddoppia HL
			JP C,SBSCRER			; Se CY=1, passa alla 0x273D (L273D SBSCRER)
			EX DE,HL				; Scambia DE ed HL
			ADD HL,HL				; Raddoppia HL
			EX DE,HL				; Scambia DE ed HL
			JR NC,L0BC1				; Se CY=0, passa alla 0x0BC1
			ADD HL,BC				; Somma BC ad HL
			JP C,SBSCRER			; Se CY=1, passa alla 0x273D (L273D SBSCRER)
L0BC1		DEC A					; Decrementa D
			JR NZ,L0BB4				; Se diverso da zero, passa a 0x0BB4
L0BC4		EX DE,HL				; Scambia DE ed HL
			POP HL					; Recupera HL dallo stack
			RET						; Return

			;
			; Routine 0x0BC7
			;
L0BC7		LD A,H					; Copia H in A
			RLA						; Ruota A a sinistra di 1 bit
			SBC A,A					; Sottrae A da A
			LD B,A					; Copia A in B
			CALL L0C51				; Chiama la 0x0C51 (L0C51 ?)
			LD A,C					; Copia C in A
			SBC A,B					; Sottrae B da A
			JR L0BD5				; Passa a 0x0B5D (L0B5D ?)

			;
			; Routine 0x0BD2
			;
L0BD2		LD A,H					; Copia H in A
			RLA						; Ruota A a sinitra di 1 bit
			SBC A,A					; Sottrae A da A
L0BD5		LD B,A					; Copia A da B
			PUSH HL					; Salva HL nello stack
			LD A,D					; Copia D in A
			RLA						; Ruota A a sinitra di 1 bit
			SBC A,A					; Sottrae A da A
			ADD HL,DE				; Somma DE ad HL
			ADC A,B					; Somma B ad A
			RRCA					; Ruota A a destra di 1 bit
			XOR H					; Esegue XOR di H con A
			JP P,MVI2FPREG			; Se positivo, passa a 0x0A99 (L0A99 MVI2FPREG)
			PUSH BC					; Salva BC nello stack
			EX DE,HL				; Scambia DE ed HL
			CALL L0ACF				; Chiama la 0x0ACF (L0ACF ?)
			POP AF					; Recupera AF dallo stack
			POP HL					; Recupera HL dallo stack
			CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)
			EX DE,HL				; Scambia DE ed HL
			CALL L0C6B				; Chiama la 0x0C6B (L0C6B ?)
			JP L0F8F				; Passa a 0x0F8F
			
			;
			; Routine 0x0BF2 
			;
L0BF2		LD A,H					; Copia H in A
			OR L					; Esegue OR di A con L
			JP Z,MVHL2FPR			; Se zero, passa alla 0x0A9A (L0A9A MVHL2FPR)
			PUSH HL					; Salva HL nello stack
			PUSH DE					; Salva DE nello stack
			CALL L0C45				; Chiama la 0x0C45 (L0C45 ?)
			PUSH BC					; Salva BC nello stack
			LD B,H					; Copia H in B
			LD C,L					; Copia L in C
			LD HL,0x0000			; Azzera HL
			LD A,0x10				; Carica in A il valore 0x10
L0C04		ADD HL,HL				; Raddoppia HL
			JR C,L0C26				; Se CY=1, passa a 0x0C26
			EX DE,HL				; Scambia DE ed HL
			ADD HL,HL				; Raddoppia HL
			EX DE,HL				; Scambia DE ed HL
			JR NC,L0C10				; Se CY=0, passa a 0x0C10
			ADD HL,BC				; Somma BC ad HL
			JP C,L0C26				; Se CY=1, passa a 0x0C26
L0C10		DEC A					; Decrementa A
			JR NZ,L0C04				; Se diverso da zero, passa a 0x0C04
			POP BC					; Recupera BC dallo stack
			POP DE					; Recupera DE dallo stack
			LD A,H					; Copia H in A
			OR A					; Esegue OR di A 
			JP M,L0C1F				; Se negativo, passa a 0x0C1F
			POP DE					; Recupera DE dallo stack
			LD A,B					; Copia B in A
			JP L0C4D				; Passa a 0x0C4D
L0C1F		XOR 0x80				; Esegue lo XOR di A con il valore 0x80
			OR L					; Esegue OR di A con L
			JR Z,L0C37				; Se zero, passa a 0x0C37
			EX DE,HL				; Scambia DE ed HL
			.BYTE 0x01				; LD BC,0xE1C1 - Skip POP HL e POP BC
L0C26		POP BC					; Recupera BC dallo stack
			POP HL					; Recupera HL dallo stack
			CALL L0ACF				; Chiama la 0x0ACF (L0ACF ?)
			POP HL					; Recupera HL dallo stack
			CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)
			CALL L0ACF				; Chiama la 0x0ACF (L0ACF ?)
L0C32		POP BC					; Recupera BC dallo stack
			POP DE					; Recupera DE dallo stack
			JP FPMULT				; Chiama la 0x0847 (L0847 FPMULT Moltiplica BCDE per FPREG)
			;
L0C37		LD A,B					; Copia B in A
			OR A					; Esegue OR di A
			POP BC					; Recupera BC dallo stack
			JP M,MVHL2FPR			; Se negativo, passa alla 0x0A9A (L0A9A MVHL2FPR)
			PUSH DE					; Salva DE nello stack
			CALL L0ACF				; Chiama la 0x0ACF (L0ACF ?)
			POP DE					; Recupera DE dallo stack
			JP L0982				; Chiama la 0x0982 (L0982 INVSGN)

			;
			; Routine 0x0C45
			;
L0C45		LD A,H					; Copia H in A
			XOR D					; Esegue lo XOR di A con D
			LD B,A					; Copia A in B
			CALL L0C4C				; Chiama la 0x0C4C (L0C4C ?)
			EX DE,HL				; Scambia DE ed HL
									;   continua con la 0x0C4C (L0C4C ?)

			;
			; Routine 0x0C4C
			;
L0C4C		LD A,H					; Copia H in A
L0C4D		OR A					; Esegue OR di A
			JP P,MVHL2FPR			; Se positivo, passa alla 0x0A9A (L0A9A MVHL2FPR)

			;
			; Routine 0x0C51 - CPLHL  Complementa intero a 16 bit in HL e lo salva in FPREG
			;
L0C51		XOR A					; Azzera A
			LD C,A					; Copia A in C
			SUB L					; Sottrae L da A
			LD L,A					; Copia A in L
			LD A,C					; Copia C in A
			SBC A,H					; Sottrae H da A con CY
			LD H,A					; Copia A in H
			JP MVHL2FPR				; Passa alla 0x0A9A (L0A9A MVHL2FPR)

			;
			; Routine 0x0C5B - INVSGINT  Inverte segno ad intero in FPREG
			;
L0C5B		LD HL,(FPREG)			; Carica in HL da memoria puntata da (0x4121) FPREG
			CALL L0C51				; Chiama la 0x0C51 (L0C51 CPLHL)
			LD A,H					; Copia H in A
			XOR 0x80				; Esegue XOR di A con il valore 0x80
			OR L					; Esegue OR di A con L
			RET NZ					; Se diverso da zero, ritorna
									;   altrimenti continua con 0x0C66 (L0C66 ?)

			;
			; Routine 0x0C66 - Check overflow di intero?
			;
L0C66 		EX DE,HL				; Scambia DE ed HL
			CALL SVSNG				; Chiama la 0x0AEF (L0AEF SVSNG)
			XOR A					; Azzera A
L0C6B		LD B,0x98				; Carica in B il valore 0x98
			JP L0969				; Passa a 0x0969 (L0969 ?)

			;
			; Routine 0x0C70
			;
L0C70		LD HL,0x412D			; Carica in HL il valore 0x412D
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			XOR 0x80				; Esegue XOR di A con il valore 0x80 (set bit7)
			LD (HL),A				; Salva A in memoria puntata da (HL)
									;   continua con la 0x0C77 (L0C77 ?)
			
			;
			; Routine 0x0C77
			;
L0C77		LD HL,0x412E			; Carica in HL il valore 0x412E (puntatore a ?)
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			OR A					; Esegue OR di A
			RET Z					; Se zero, ritorna
			LD B,A					; Copia A in B
			DEC HL					; Decrementa HL
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			LD DE,FPEXP				; Carica in DE il valore 0x4124 (puntatore a FPEXP)
			LD A,(DE)				; Carica in A da memoria puntata da (DE)
			OR A					; Esegue OR di A
			JP Z,L09F4				; Se zero, passa a 0x09F4 (L09F4 MVTMPFPS)
			SUB B					; Sottrae B di A
			JR NC,L0CA1				; Se CY=0, passa a 0x0CA1
			CPL						; Complementa A
			INC A					; Incrementa A
			PUSH AF					; Salva AF nello stack
			LD C,0x08				; Carica in C il valore 0x08
			INC HL					; Incrementa HL
			PUSH HL					; Salva HL nello stack
L0C92		LD A,(DE)				; Carica in A da memoria puntata da (DE)
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			LD (HL),A				; Salva A in memoria puntata da (HL)
			LD A,B					; Copia B in A
			LD (DE),A				; Salva A in memoria puntata da (DE)
			DEC DE					; Decrementa DE
			DEC HL					; Decrementa HL
			DEC C					; Decrementa C
			JR NZ,L0C92				; Se diverso da zero, passa a 0x0C92
			POP HL					; Recupera HL dallo stack
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			DEC HL					; Decrementa HL
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			POP AF					; Recupera AF dallo stack
L0CA1		CP 0x39					; Compara A con il valore 0x39 (carattere '9')
			RET NC					; Se CY=0, ritorna
			PUSH AF					; Salva AF nello stack
			CALL SIGNS				; Chiama la 0x09DF (L09DF SIGNS)
			INC HL					; Incrementa HL
			LD (HL),0x00			; Azzera memoria puntata da (HL)
			LD B,A					; Copia A in B
			POP AF					; Recupera AF dallo stack
			LD HL,0x412D			; Carica in HL il valore 0x412D
			CALL L0D69				; Chiama la 0x0D69 (L0D69 ?)
			LD A,(0x4126)			; Carica in A da memoria puntata da (0x4126)
			LD (0x411C),A			; Salva A in memoria puntata da (0x411C)
			LD A,B					; Copia B in A
			OR A					; Esegue OR di A
			JP P,L0CCF				; Se positivo, passa a 0x0CCF (L0CCF ?)
			CALL L0D33				; Chiama la 0x0D33 (L0D33 ?)
			JP NC,L0D0E				; Se CY=0, passa a 0x0D0E
			EX DE,HL				; Scambia DE ed HL
			INC (HL)				; Incrementa memoria puntata da (HL)
			JP Z,OVERR				; Se zero, passa a 0x07B2 (L07B2 OVERR)
			CALL L0D90				; Chiama la 0x0D90 (L0D90 ?)
			JP L0D0E				; Passa a 0x0D0E (L0D0E ?)

			;
			; Routine 0x0CCF
			;
L0CCF		CALL L0D45				; Chiama la 0x0D45 (L0D45 ?)
			LD HL,0x4125			; Carica in HL il valore 0x4125
			CALL C,L0D57			; Chiama la 0x0D57 (L0D57 ?)
L0CD8		XOR A					; Azzera A
L0CD9		LD B,A					; Copia A in B
			LD A,(FPREGMSB)			; Carica in A da memoria puntata da (0x4123) FPREGMSB		; Get MSB of FPREG
			OR A					; Esegue OR di A
			JR NZ,L0CFE				; Se diverso da zero, passa a 0x0CFE
			LD HL,0x411C			; Carica in HL il valore 0x411C
			LD C,0x08				; Carica in C il valore 0x08
L0CE5		LD D,(HL)				; Carica in D da memoria puntata da (HL)
			LD (HL),A				; Salva A in memoria puntata da (HL)
			LD A,D					; Copia D in A
			INC HL					; Incrementa HL
			DEC C					; Decrementa C
			JR NZ,L0CE5				; Se diverso da zero, passa a 0x0CE5
			LD A,B					; Copia B in A
			SUB 0x08				; Sottrae da A il valore 0x08
			CP 0xC0					; Compara A con il valore 0xC0
			JR NZ,L0CD9				; Se diverso da zero, passa a 0x0CD9
			JP ZREXP				; Passa alla 0x0778 (L0778 ZREXP)

			;
			; Routine 0x0CF6
			;
L0CF6		DEC B					; Decrementa B
			LD HL,0x411C			; Carica in HL il valore 0x411C
			CALL L0D97				; Chiama la 0x0D97 (L0D97 ?)
			OR A					; Esegue OR di A
L0CFE		JP P,L0CF6				; Se positivo, passa a 0x0CF6
			LD A,B					; Copia B in A
			OR A					; Esegue OR di A
			JR Z,L0D0E				; Se zero, passa alla 0x0D0E (L0D0E ?)
			LD HL,FPEXP				; Carica in HL il valore 0x4124 (puntatore a FPEXP)
			ADD A,(HL)				; Somma ad A memoria puntata da (HL)
			LD (HL),A				; Salva A in memoria puntata da (HL)
			JP NC,ZREXP				; Se CY=0, passa alla 0x0778 (L0778 ZREXP)
			RET Z					; Se zero, ritorna
									;   altrimenti, continua con 0x0D0E (L0D0E ?)

			;
			; Routine 0x0D0E
			;
L0D0E		LD A,(0x411C)			; Carica in A da memoria puntata da (0x411C)
L0D11		OR A					; Esegue OR di A
			CALL M,L0D20			; Se negativo, chiama la 0x0D20 (L0D20 ?)
			LD HL,0x4125			; Carica in HL il valore 0x4125
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			AND 0x80				; Esegue AND di A con il valore 0x80
			DEC HL					; Decrementa HL
			DEC HL					; Decrementa HL
			XOR (HL)				; Esegue XOR di A con memoria puntata da (HL)
			LD (HL),A				; Salva A in memoria puntata da (HL)
			RET						; Ritorna

			;
			; Routine 0x0D20
			;
L0D20		LD HL,TDBL1				; Carica in HL il valore 0x411D (puntatore a TDBL1)
			LD B,0x07				; Carica in B il valore 0x07
L0D25		INC (HL)				; Incrementa memoria puntata da (HL)
			RET NZ					; Se diverso da zero, ritorna
			INC HL					; Incrementa HL
			DEC B					; Decrementa B
			JR NZ,L0D25				; Se diverso da zero, passa a 0x0D25
			INC (HL)				; Incrementa memoria puntata da (HL)
			JP Z,OVERR				; Se zero, passa a 0x07B2 (L07B2 OVERR)
			DEC HL					; Decrementa HL
			LD (HL),0x80			; Salva il valore 0x80 in memoria puntata da (HL)
			RET						; Ritorna

			;
			; Routine 0x0D33
			;
L0D33		LD HL,UNK05				; Carica in HL il valore 0x4127 (puntatore a UNK05)
L0D36		LD DE,TDBL1				; Carica in DE il valore 0x411D (puntatore a TDBL1)
L0D39		LD C,0x07				; Carica in C il valore 0x07
			XOR A					; Azzera A
L0D3C		LD A,(DE)				; Carica in A da memoria puntata da (DE)
			ADC A,(HL)				; Somma A a memoria puntata da (HL)
			LD (DE),A				; Salva A in memoria puntata da (DE)
			INC DE					; Incrementa DE
			INC HL					; Incrementa HL
			DEC C					; Decrementa C
			JR NZ,L0D3C				; Se diverso da zero, passa a 0x0D3C
			RET						; Ritorna

			;
			; Routine 0x0D45
			;
L0D45		LD HL,UNK05				; Carica in HL il valore 0x4127 (puntatore a UNK05)
L0D48		LD DE,TDBL1				; Carica in DE il valore 0x411D (puntatore a TDBL1)
L0D4B		LD C,0x07				; Carica in C il valore 0x07
			XOR A					; Azzera A
L0D4E		LD A,(DE)				; Carica in A da memoria puntata da (DE)
			SBC A,(HL)				; Sottrae da A memoria puntata da (HL)
			LD (DE),A				; Salva A in memoria puntata da (DE)
			INC DE					; Incrementa DE
			INC HL					; Incrementa HL
			DEC C					; Decrementa C
			JR NZ,L0D4E				; Se diverso da zero, passa a 0x0D4E
			RET     				; Ritorna

			;
			; Routine 0x0D57
			;
L0D57		LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CPL						; Complementa A
			LD (HL),A				; Salva A in memoria puntata da (HL)
			LD HL,0x411C			; Carica in DE il valore 0x411C (puntatore a ?)
			LD B,0x08				; Carica in B il valore 0x08
			XOR A					; Azzera A
			LD C,A					; Copia A in C
L0D61		LD A,C					; Copia C in A
			SBC A,(HL)				; Sottrae da A memoria puntata da (HL)
			LD (HL),A				; Salva A in memoria puntata da (HL)
			INC HL					; Incrementa HL
			DEC B					; Decrementa B
			JR NZ,L0D61				; Se diverso da zero, passa a 0x0D61
			RET     				; Ritorna

			;
			; Routine 0x0D69
			;
L0D69		LD (HL),C				; Salva C in memoria puntata da (HL)
			PUSH HL					; Salva HL nello stack
L0D6B		SUB 0x08				; Sottrae da A il valore 0x08
			JR C,L0D7D				; Se CY=1, passa a 0x0D7D
			POP HL					; Recupera HL dallo stack
L0D70		PUSH HL					; Salva HL nello stack
			LD DE,0x0800			; Carica in DE il valore 0x0800
L0D74		LD C,(HL)				; Carica in C da memoria puntata da (HL)
			LD (HL),E				; Salva E in memoria puntata da (HL)
			LD E,C					; Copia C in E
			DEC HL					; Decrementa HL
			DEC D					; Decrementa D
			JR NZ,L0D74				; Se diverso da zero, passa a 0x0D74
			JR L0D6B				; Passa a 0x0D6B
L0D7D		ADD A,0x09				; Somma ad A il valore 0x09
			LD D,A					; Copia A in D
L0D80		XOR A					; Azzera A
			POP HL					; Recupera HL dallo stack
			DEC D					; Decrementa D
			RET Z					; Se zero, ritorna
									;   altrimenti passa a 0x0D84 (L0D84 ?)

												;
			; Routine 0x0D84
			;
L0D84		PUSH HL					; Salva HL nello stack
			LD E,0x08				; Carica in E il valore 0x08
L0D87		LD A,(HL)				; Carica in A da memoria puntata da (HL)
			RRA						; Ruota A a destra di 1 bit
			LD (HL),A				; Salva A in memoria puntata da (HL)
			DEC HL					; Decrementa HL
			DEC E					; Decrementa E
			JR NZ,L0D87				; Se diverso da zero, passa a 0x0D87
			JR L0D80				; Passa a 0x0D80
L0D90		LD HL,FPREGMSB			; Carica in HL il valore 0x4123 (puntatore a FPREGMSB)
			LD D,0x01				; Carica in D il valore 0x01
			JR L0D84				; Passa a 0x0D84
			
			;
			; Routine 0x0D97
			;
L0D97		LD C,0x08				; Carica in C il valore 0x08
									;   continua con la 0x0D99 (L0D99 ?)

			;
			; Routine 0x0D99
			;
L0D99		LD A,(HL)				; Carica in A da memoria puntata da (HL)
			RLA						; Ruota A a sinistra di 1 bit
			LD (HL),A				; Salva A in memoria puntata da (HL)
			INC HL					; Incrementa HL
			DEC C					; Decrementa C
			JR NZ,L0D99				; Se diverso da zero, passa a 0x0D99
			RET						; Ritorna

			;
			; Routine 0x0DA1
			;
L0DA1		CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)
			RET Z					; Se zero, ritorna
			CALL L090A				; Chiama la 0x090A (L090A ?)
			CALL L0E39				; Chiama la 0x0E39 (L0E39 ?)
			LD (HL),C				; Salva C in memoria puntata da (HL)
			INC DE					; Incrementa DE
			LD B,0x07				; Carica in B il valore 0x07
L0DAF		LD A,(DE)				; Carica in A da memoria puntata da (DE)
			INC DE					; Incrementa DE
			OR A					; Esegue OR di A
			PUSH DE					; Salva DE nello stack
			JR Z,L0DCC				; Se zero, passa a 0x0DCC
			LD C,0x08				; Carica in C il valore 0x08
L0DB7		PUSH BC					; Salva BC nello stack
			RRA						; Ruota A a destra di 1 bit
			LD B,A					; Copia A in B
			CALL C,L0D33			; Se CY=1, chiama la 0x0D33 (L0D33 ?)
			CALL L0D90				; Chiama la 0x0D90 (L0D90 ?)
			LD A,B					; Copia B in A
			POP BC					; Recupera BC dallo stack
			DEC C					; Decrementa C
			JR NZ,L0DB7				; Se diverso da zero, passa a 0x0DB7
L0DC5		POP DE					; Recupera DE dallo stack
			DEC B					; Decrementa B
			JR NZ,L0DAF				; Se diverso da zero, passa a 0x0DAF
			JP L0CD8				; Passa alla 0x0CD8 (L0CD8 ?)
L0DCC		LD HL,FPREGMSB			; Carica in HL il valore 0x4123 (puntatore a FPREGMSB)
			CALL L0D70				; Chiama la 0x0D70 (L0D70 ?)
			JR L0DC5				; Passa alla 0x0DC5 (L0DC5 ?)

			;
			; Valori FP notevoli
			;
FPZERO		.BYTE 0x00, 0x00, 0x00, 0x00		;  0.0
FPTEN		.BYTE 0x00, 0x00, 0x20, 0x84		; 10.0

			;
			; Routine 0x0DDC
			;
L0DDC		LD DE,FPZERO			; Carica in DE il valore 0x0DD4 (puntatore a FPZERO)
			LD HL,UNK05				; Carica in HL il valore 0x4127 (puntatore a UNK05)
			CALL CPYVDEHL				; Chiama la 0x09D3 (L09D3 CPYVDEHL)
L0DE5		LD A,(0x412E)			; Carica in A da memoria puntata da (0x412E)
			OR A					; Esegue OR di A
			JP Z,DZERR				; Se zero, passa a 0x199A (L199A DZERR) 				; Error if division by zero
			CALL L0907				; Chiama la 0x0907 (L0907 ?)
			INC (HL)				; Incrementa memoria puntata da (HL)
			INC (HL)				; Incrementa memoria puntata da (HL)
			CALL L0E39				; Chiama la 0x0E39 (L0E39 ?)
			LD HL,0x4151			; Carica in HL il valore 0x4151
			LD (HL),C				; Salva C in memoria condivisa da (HL)
			LD B,C					; Copia C in B
L0DF9		LD DE,0x414A			; Carica in HL il valore 0x414A
			LD HL,UNK05				; Carica in HL il valore 0x4127 (puntatore a UNK05)
			CALL L0D4B				; Chiama la 0x0D4B (L0D4B ?)
			LD A,(DE)				; Carica in A da memoria puntata da (DE)
			SBC A,C					; Sottrae C da A
			CCF						; Inverte CY
			JR C,L0E12				; Se CY=1, passa a 0x0E12
			LD DE,0x414A			; Carica in HL il valore 0x414A
			LD HL,UNK05				; Carica in HL il valore 0x4127 (puntatore a UNK05)
			CALL L0D39				; Chiama la 0x0D39 (L0D39 ?)
			XOR A					; Azzera A
			.BYTE 0xDA				; Esegue JP C,L0412, skip LD (DE),A e INC B e passa a 0x0E14 (L0E14)
L0E12		LD (DE),A				; Salva A in memorida puntata da (DE)
			INC B					; Incrementa B
			;
L0E14		LD A,(FPREGMSB)			; Carica in A da memoria puntata da (0x4123) FPREGMSB
			INC A					; Incrementa A
			DEC A					; Decrementa A
			RRA						; Ruota A a destra di 1 bit
			JP M,L0D11				; Se negativo, passa a 0x0D11
			RLA						; Ruota A a sinistra di 1 bit
			LD HL,TDBL1				; Carica in HL il valore 0x411D (puntatore a TDBL1)
			LD C,0x07				; Carica in C il valore 0x07
			CALL L0D99				; Chiama la 0x0D99 (L0D99 ?)
			LD HL,0x414A			; Carica in HL il valore 0x414A
			CALL L0D97				; Chiama la 0x0D97 (L0D97 ?)
			LD A,B					; Copia B in A
			OR A					; Esegue OR di A
			JR NZ,L0DF9				; Se diverso da zero, passa a 0x0DF9
			LD HL,FPEXP				; Carica in HL il valore 0x4124 (puntatore a FPEXP)
			DEC (HL)				; Decrementa memoria puntata da (HL)
			JR NZ,L0DF9				; Se diverso da zero, passa a 0x0DF9
			JP OVERR				; Passa alla 0x07B2 (L07B2 OVERR)

			;
			; Routine 0x0E39
			;   Input: C ?
			;
L0E39		LD A,C					; Copia C in A
			LD (0x412D),A			; Salva A in memoria puntata da (0x412D)
			DEC HL					; Decrementa HL
			LD DE,MULLSB			; Carica in DE il valore 0x4150 (puntatore a MULLSB)
			LD BC,0x0700			; Carica in BC il valore 0x0700
L0E44		LD A,(HL)				; Carica in A da memoria puntata da (HL)
			LD (DE),A				; Salva A in memoria puntata da (DE)
			LD (HL),C				; Salva C in memoria puntata da (HL)
			DEC DE					; Decrementa DE 
			DEC HL					; Decrementa HL
			DEC B					; Decrementa B
			JR NZ,L0E44				; Se diverso da zero, passa a 0x0E44
			RET						; Ritorna

			;
			; Routine 0x0E4D
			;
L0E4D		CALL L09FC				; Chiama la 0x09FC (L09FC MVFPSTMP)
			EX DE,HL				; Scambia DE ed HL
			DEC HL					; Decrementa HL
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			OR A					; Esegue OR di A
			RET Z					; Se zero, ritorna
			ADD A,0x02				; Somma ad A il valore 0x02
			JP C,OVERR				; Se CY=1, passa a 0x07B2 (L07B2 OVERR)
			LD (HL),A				; Salva A in memoria puntata da (HL)
			PUSH HL					; Salva HL nello stack
			CALL L0C77				; Chiama la 0x0C77 (L0C77 ?)
			POP HL					; Recupera HL dallo stack
			INC (HL)				; Incrementa memoria puntata da (HL)
			RET NZ					; Se diverso da zero, ritorna
			JP OVERR				; Passa a 0x07B2 (L07B2 OVERR)
L0E65		CALL ZREXP				; Chiama la 0x0778 (L0778 ZREXP)
			CALL L0AEC				; Chiama la 0x0AEC (L0AEC SVDBL)

			;
			; Routine 0x0E6B - POR  Esegue la OR
			;
L0E6B		.BYTE 0xF6				; Esegue OR 0xAF													; Flag "OR"
									;   continua con la 0x0E6D (L0E6D) - Skip XOR A

			;
			; Routine 0x0E6C - PAND  Esegue la AND
			;
L0E6C 		XOR A					; Azzera A															; Flag "AND"
L0E6D		EX DE,HL				; Scambia DE ed HL													; Save "AND" / "OR" flag
			LD BC,0x00FF			; Carica in BC il valore 0x00FF										
			LD H,B					; Copia B in H														
			LD L,B					; Copia B in L														
			CALL Z,MVHL2FPR			; Se zero, chiama la 0x0A9A (L0A9A MVHL2FPR)							
			EX DE,HL				; Scambia DE ed HL													
			LD A,(HL)				; Carica in A da memoria puntata da (HL)							
			CP '-'					; Compara A con il valore 0x2D (carattere '-')
			PUSH AF					; Salva AF nello stack
			JP Z,L0E83				; Se uguale, passa a 0x0E83
			CP '+'					; Compara A con il valore 0x2B (carattere '+')		
			JR Z,L0E83				; Se uguale, passa a 0x0E83
			DEC HL					; Decrementa HL
									;    continua con la 0x0E83 (L0E83 ?)

			;
			; Routine 0x0E83
			;
L0E83		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			JP C,L0F29				; Se CY=1, passa a 0x0F29 (L0F29 GETDIG)
			CP '.'					; Compara A con il valore 0x2E (carattere '.')		
			JP Z,L0EE4				; Se uguale, passa a 0x0EE4 (L0EE4 ?)
			CP 'E'					; Compara A con il valore 0x45 (carattere 'E')		
			JR Z,L0EA4				; Se uguale, passa a 0x0EA4
			CP '%'					; Compara A con il valore 0x25 (carattere '%')		
			JP Z,L0EEE				; Se uguale, passa a 0x0EEE (L0EEE ?)
			CP '#'					; Compara A con il valore 0x23 (carattere '#')		
			JP Z,L0EF5				; Se uguale, passa a 0x0EF5 (L0EF5 ?)
			CP '!'					; Compara A con il valore 0x21 (carattere '!')		
			JP Z,L0EF6				; Se uguale, passa a 0x0EF6 (L0EF6 ?)
			CP 'D'					; Compara A con il valore 0x44 (carattere 'D')		
			JR NZ,L0EC7				; Se diverso, passa a 0x0EC7 (L0EC7 ?)
			OR A					; Esegue OR di A
L0EA4		CALL L0EFB				; Chiama la 0x0EFB (L0EFB ?)
			PUSH HL					; Salva HL nello stack
			LD HL,0x0EBD			; Carica in HL il valore 0x0EBD (puntatore a EXPLP)
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			DEC D					; Decrementa D
			CP TKMINUS				; Compara A con il valore 0xCE (Token -)		
			RET Z					; Se uguale, ritorna
			CP '-'					; Compara A con il valore 0x2D (carattere '-')		
			RET Z					; Se uguale, ritorna
			INC D					; Incrementa D
			CP TKPLUS				; Compara A con il valore 0xCD (Token +)		
			RET Z					; Se uguale, ritorna
			CP '+'					; Compara A con il valore 0x2B (carattere '+')		
			RET Z					; Se uguale, ritorna
			DEC HL					; Decrementa HL
			POP AF					; Recupera AF dallo stack
									;   continua con la 0x0EBD (L0EBD EXPLP)
		
			;
			; Routine 0x0EBD - EXPLP
			;
L0EBD		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)						; Get next character
			JP C,L0F94				; Se CY=1, passa a 0x0F94 (L0F94 EDIGIT)				; Digit - Add to exponent
			INC D					; Incrementa D											; Is sign negative?
			JR NZ,L0EC7				; Se diverso da zero, passa alla 0x0EC7 (L0EC7 CONEXP)	; No - Scale number
			XOR A					; Azzera A
			SUB E					; Sottrae E da A										; Negate exponent
			LD E,A					; Copia A in E											; And re-save it
									;   continua con la 0x0EC7 (L0EC7 CONEXP)

			;
			; Routine 0x0EC7 - CONEXP
			;
L0EC7		PUSH HL					; Salva HL nello stack									; Save code string address
			LD A,E					; Copia E in A											; Get exponent
			SUB B					; Sottrae B da A										; Subtract digits after point
L0ECA		CALL P,L0F0A			; Se positivo, chiama la 0x0F0A (L0F0A SCALPL)			; Positive - Multiply number
			CALL M,L0F18			; Se negativo, chiama la 0x0F18 (L0F18 DIVTEN)			; Negative - Divide number	
			JR NZ,L0ECA				; Se diverso da zero, passa a 0x0ECA					; More to do
			POP HL					; Recupera HL dallo stack								; Restore code string address
			POP AF					; Recupera AF dallo stack								; Restore sign of number
			PUSH HL					; Salva HL nello stack									; Save code string address
			CALL Z,L097B			; Se zero, chiama la 0x097B (L097B INVSGN)
			POP HL					; Recupera HL dallo stack								; Restore code string address
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			RET PE					; Se pe, ritorna
			PUSH HL					; Salva HL nello stack
			LD HL,0x0890			; Carica in HL il valore 0x0890
			PUSH HL					; Salva HL nello stack
			CALL CMPM32K			; Chiama la 0x0AA3 (L0AA3 CMPM32K)
			RET						; Ritorna

			;
			; Routine 0x0EE4
			;
L0EE4		RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			INC C					; Incrementa C
			JR NZ,L0EC7				; Se diverso da zero, passa alla 0x0EC7 (L0EC7 CONEXP)
			CALL C,L0EFB			; Se CY=1, chiama la 0x0EFB (L0EFB ?)
			JP L0E83				; Passa alla 0x0E83 (L0E83 ?)

			;
			; Routine 0x0EEE
			;
L0EEE		RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			JP P,SNERR				; Se positivo, passa a 0x1997 (L1997 SNERR)
L0EF2		INC HL					; Incrementa HL
			JR L0EC7				; Passa alla 0x0EC7 (L0EC7 ?)

			;
			; Routine 0x0EF5
			;
L0EF5		OR A					; Esegue OR di A
L0EF6		CALL L0EFB				; Chiama la 0x0EFB (L0EFB ?)
			JR L0EF2				; Passa alla 0x0EF2 (L0EF2 ?)

			;
			; Routine 0x0EFB
			;
L0EFB		PUSH HL					; Salva HL nello stack
			PUSH DE					; Salva DE nello stack
			PUSH BC					; Salva BC nello stack
			PUSH AF					; Salva AF nello stack
			CALL Z,CSNG				; Se zero, chiama la 0x0AB1 (L0AB1 CSNG)
			POP AF					; Recupera AF dallo stack
			CALL NZ,CDBL			; Se diverso da zero, chiama la 0x0ADB (L0ADB CDBL)
			POP BC					; Recupera BC dallo stack
			POP DE					; Recupera DE dallo stack
			POP HL					; Recupera HL dallo stack
			RET						; Ritorna

			;
			; Routine 0x0F0A - SCALPL
			;
L0F0A		RET Z					; Se zero, ritorna
									;   altrimenti passa alla 0x0F0B (L0F0B MULTEN)

			;
			; Routinte 0x0F0B - MULTEN  Moltiplica per 10
			;
MULTEN		PUSH AF					; Salva AF nello stack							; Save count
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			PUSH AF					; Salva AF nello stack						
			CALL PO,MLSP10			; Se po, chiama la 0x093E (L093E MLSP10)		; Multiply number by 10
			POP AF					; Recupera AF dallo stack						; Restore count
			CALL PE,L0E4D			; Se pe, chiama la 0x0E4D (L0E4D ?)
			POP AF					; Recupera AF dallo stack
									;   continua con la 0x0F16 (L0F16 DECA)

			;
			; Routine 0x0F16 - DECA  Decrementa A
			;
L0F16		DEC A					; Decrementa A									; Count multiplies
			RET						; Ritorna

			;
			; Routine 0x0F18 - DIVTEN  Divide per 10
			;
L0F18		PUSH DE					; Salva DE nello stack							
			PUSH HL					; Salva HL nello stack							
			PUSH AF					; Salva AF nello stack							
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)			
			PUSH AF					; Salva AF nello stack							
			CALL PO,L0897			; Se po, chiama la 0x0897 (L0897 DIV10)			
			POP AF					; Recupera AF dallo stack						
			CALL PE,L0DDC			; Se pe, chiama la 0x0DDC (L0DDC ?)				
			POP AF					; Recupera AF dallo stack						
			POP HL					; Recupera HL dallo stack						
			POP DE					; Recupera DE dallo stack						
			INC A					; Incrementa A									
			RET						; Ritorna										
																									
			;
			; Routine 0x0F29 - GETDIG  Gestisce una cifra
			;
L0F29		PUSH DE					; Salva DE nello stack
			LD A,B					; Copia B in A	
			ADC A,C					; Somma C ad A
			LD B,A					; Copia A in B
			PUSH BC					; Salva BC nello stack
			PUSH HL					; Salva HL nello stack
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			SUB 0x30				; Sottrae da A il valore 0x30 (carattere '0')
			PUSH AF					; Salva AF nello stack
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			JP P,L0F5D				; Se positivo, passa a 0x0F5D (L0F5D ?)
			LD HL,(FPREG)			; Carica in HL da memoria puntata da (0x4121) FPREG
			LD DE,0x0CCD			; Carica in DE il valore 0x0CCD
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR NC,L0F59				; Se CY=0, passa a 0x0F59 (L0F59 ?)
			LD D,H					; Copia H in D
			LD E,L					; Copia L in E
			ADD HL,HL				; Raddoppia HL
			ADD HL,HL				; Raddoppia HL
			ADD HL,DE				; Somma DE ad HL
			ADD HL,HL				; Raddoppia HL
			POP AF					; Recupera AF dallo stack
			LD C,A					; Copia A in C
			ADD HL,BC				; Somma BC ad HL
			LD A,H					; Copia H in A
			OR A					; Esegue OR di A
			JP M,L0F57				; Se negativo, passa alla 0x0F57 (L0F57 ADDIG)
			LD (FPREG),HL			; Salva HL in memoria puntata da (HL) FPREG
L0F51		POP HL					; Recupera HL dallo stack
			POP BC					; Recupera BC dallo stack
			POP DE					; Recupera DE dallo stack
			JP L0E83				; Passa a 0x0E83 (L0E83 ?)

			;
			; Routine 0x0F57 - ADDIG 
			;
L0F57		LD A,C					; Copia C in A
			PUSH AF					; Salva AF nello stack
L0F59		CALL L0ACC				; Chiama la 0x0ACC (L0ACC ?)
			SCF						; CY=1
L0F5D		JR NC,L0F77				; Se CY=0, passa a 0x0F77
			LD BC,0x9474			; Carica in BC il valore 0x9474				; 999999.9 ?
			LD DE,0x2400			; Carica in DE il valore 0x2400
			CALL CMPNUM				; Chiama la 0x0A0C (L0A0C CMPNUM)
			JP P,L0F74				; Se positivo, passa a 0x0F74
			CALL MLSP10				; Chiama la 0x093E (L093E MLSP10)
			POP AF					; Recupera AF dallo stack
			CALL RSCALE				; Chiama la 0x0F89 (L0F89 RSCALE)
			JR L0F51				; Passa a 0x0F51 (L0F51 ?)
			;
L0F74		CALL L0AE3				; Chiama la 0x0AE3 (L0AE3 ?)
L0F77		CALL L0E4D				; Chiama la 0x0E4D (L0E4D ?)
			CALL L09FC				; Chiama la 0x09FC (L09FC MVFPSTMP)
			POP AF					; Recupera AF dallo stack
			CALL FLGREL				; Chiama la 0x0964 (L0964 FLGREL)          ; Digit to add to FPREG
			CALL L0AE3				; Chiama la 0x0AE3 (L0AE3 ?)
			CALL L0C77				; Chiama la 0x0C77 (L0C77 ?)
			JR L0F51				; Passa a 0x0F51 (L0F51 ?)

			;
			; Routine 0x0F89 - RSCALE
			;
RSCALE		CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)
			CALL FLGREL				; Chiama la 0x0964 (L0964 FLGREL)				 ; Digit to add to FPREG
L0F8F		POP BC					; Recupera BC dallo stack
			POP DE					; Recupera DE dallo stack
			JP FPADD				; Passa alla 0x0716 (L0716 FPADD)

			;
			; Routine 0x0F94 - EDIGIT
			;
L0F94		LD A,E					; Copia E in A									; Get digit
			CP 0x0A					; Compara A con il valore 0x0A		
			JR NC,L0FA2				; Se CY=0, passa a 0x0FA2
			RLCA    				; Ruota A a sinistra di 1 bit					; Times 2
			RLCA    				; Ruota A a sinistra di 1 bit					; Times 4
			ADD A,E					; Copia E in A									; Times 5
			RLCA    				; Ruota A a sinistra di 1 bit					; Times 10
			ADD A,(HL)				; Somma ad A memoria puntata da (HL)			; Add next digit
			SUB '0'				; Sottrae da A il valore 0x30 (carattere '0')	; Make it absolute
			LD E,A					; Copia A in E									; Save new digit
			.BYTE 0xFA				; Non esegue mai JP M,L321E, skip LD E,0x32
									;   continua con 0x0FA4 (L0FA4)
									;
L0FA2		LD E,0x32				; Carica in E il valore 0x32 (carattere '2')
L0FA4		JP L0EBD				; Passa a 0x0EBD (L0EBD EXPLP)					; Look for another digit

			;
			; Routine 0x0FA7 - VLINEIN  Visualizza ' in ' XXXX 
			;   Input: HL  Numero di linea da visualizzare
			;
VLINEIN		PUSH HL
			LD HL,MINLN				; Carica in HL il valore 0x1924 (messaggio ' in ')
			CALL PRS				; Chiama la 0x28A7 (L28A7 PRS) 
			POP HL					; Recupera HL dallo stack
									;   continua con la 0x0FAF (L0FAF PRNTHL)

			;
			; Routine 0x0FAF - PRNTHL  Visualizza il valore di HL
			;
PRNTHL		CALL MVHL2FPR			; Chiama la 0x0A9A (L0A9A MVHL2FPR)
			XOR A					; Azzera A
			CALL INICVN2A			; Chiama la 0x1034 (L1034 INICVN2A)
			OR (HL)					; Esegue OR di A con memoria puntata da (HL)
			CALL L0FD9				; Chiama la 0x0FD9 (L0FD9 ?)
			JP INCHLPRS				; Passa alla 0x28A6 (L28A6 INCHLPRS)

			;
			; Routine 0x0FBD - NUMASC Converte numero in testo
			;
NUMASC		XOR A					; Azzera A
L0FBE		CALL INICVN2A			; Chiama la 0x1034 (L1034 INICVN2A)
			AND 0x08				; Esegue AND di A con il valore 0x08
			JR Z,L0FC7				; Se zero, passa a 0x0FC7
			LD (HL),'+'				; Salva il valore 0x2B (carattere '+') in memoria puntata da (HL)
L0FC7		EX DE,HL				; Scambia DE ed HL
			CALL L0994				; Chiama la 0x0994 (L0994 TSTSGNNUM)
			EX DE,HL				; Scambia DE ed HL
			JP P,L0FD9				; Se positivo, passa a 0x0FD9
			LD (HL),'-'				; Salva il valore 0x2D (carattere '-') in memoria puntata da (HL)
			PUSH BC					; Salva BC nello stack
			PUSH HL					; Salva HL nello stack
			CALL L097B				; Chiama la 0x097B (L097B INVSGN)
			POP HL					; Recupera HL dallo stack
			POP BC					; Recupera BC dallo stack
			OR H					; Esegue OR di A con H
									;  continua cona la 0x0FD9 (L0FD9)

			;
			; Routine 0x0FD9
			;
L0FD9		INC HL					; Incrementa HL
			LD (HL),'0' 			; Salva il valore 0x30 (carattere '0') in memoria puntata da (HL)
			LD A,(CUROPR)			; Carica in A memoria puntata da (0x40D8) CUROPR
			LD D,A					; Copia A in D
			RLA						; Ruota A a sinistra di 1 bit
			LD A,(TYPE)				; Carica in A memoria puntata da (0x40AF) TYPE
			JP C,L109A				; Se CY=1, passa a 0x109A (L109A ?)
			JP Z,L1092				; Se zero, passa a 0x1092 (L1092 ?)
			CP 0x04					; Compara A con il valore 0x04
			JP NC,L103D				; Se CY=0, passa a 0x103D (L103D ?)
			LD BC,0x0000			; Azzera BC
			CALL L132F				; Chiama la 0x132F (L132F ?)
									;   continua con la 0x0FF5 (L0FF5 ?)

			;
			; Routine 0x0FF5 
			;
L0FF5		LD HL,CONVBUFF			; Carica in HL il valore 0x4130 (puntatore a CONVBUFF)
			LD B,(HL)				; Carica in B memoria puntata da (HL)
			LD C,' '				; Carica in C il valore 0x20 (carattere ' ')
			LD A,(CUROPR)			; Carica in A memoria puntata da (0x40D8) CUROPR
			LD E,A					; Copia A in E
			AND 0x20				; Esegue AND di A con il valore 0x20
			JR Z,L100A				; Se zero, passa a 0x100A
			LD A,B					; Copia B in A
			CP C					; Compara A con C
			LD C,'*'				; Carica in C il valore 0x2A (carattere '*')
			JR NZ,L100A				; Se diverso, passa a 0x100A
			LD B,C					; Copia C in B
L100A		LD (HL),C				; Salva C in memoria puntata da (HL)
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			JR Z,L1022				; Se zero, passa a 0x1022
			CP 'E'					; Compara A con il valore 0x45 (carattere 'E')
			JR Z,L1022				; Se uguale, passa a 0x1022
			CP 'D'					; Compara A con il valore 0x44 (carattere 'D')
			JR Z,L1022				; Se uguale, passa a 0x1022
			CP '0'					; Compara A con il valore 0x30 (carattere '0')
			JR Z,L100A				; Se uguale, passa a 0x100A, skip zeri
			CP ','					; Compara A con il valore 0x2C (carattere ',')
			JR Z,L100A				; Se uguale, passa a 0x1022, skip ','
			CP '.'					; Compara A con il valore 0x2E (carattere '.')
			JR NZ,L1025				; Se uguale, passa a 0x1025
L1022		DEC HL					; Decrementa HL
			LD (HL),'0'				; Salva il valore 0x30 (carattere '0') nella memoria puntata da (HL)
L1025		LD A,E					; Copia E in A
			AND 0x10				; Esegue AND di A con il valore 0x10
			JR Z,L102D				; Se zero, passa a 0x102D
			DEC HL					; Decrementa HL
			LD (HL),'$'				; Salva il valore 0x24 (carattere '$') nella memoria puntata da (HL)
L102D		LD A,E					; Copia E in A
			AND 0x04				; Esegue AND di A con il valore 0x04
			RET NZ					; Se diverso da zero, ritorna
			DEC HL					; Decrementa HL
			LD (HL),B				; Salva B in memoria puntata da (HL)
			RET						; Ritorna

			;
			; Routine 0x1034 -  INICVN2A  Inizializza conversione da numero ad ASCII
			;						Azzera token operatore corrente e 
			;						inserisce spazio in primo carattere buffer
			;	Output:  HL puntatore ad inizio buffer
			;
INICVN2A	LD (CUROPR),A			; Salva A in memoria puntata da (0x40D8) CUROPR
			LD HL,CONVBUFF			; Carica in HL il valore 0x4130 (puntatore a CONVBUFF)
			LD (HL),' '				; Salva il valore 0x20 (carattere ' ') in memoria puntata da (HL)
			RET						; Ritorna

			;
			; Routine 0x103D
			;   Input: A
			;
L103D		CP 0x05					; Compara A con il valore 0x05
			PUSH HL					; Salva HL nello stack
			SBC A,0x00				; Sottrae da A il valore 0x00
			RLA						; Ruota A a sinistra di 1 bit
			LD D,A					; Copia A in D
			INC D					; Incrementa D
			CALL L1201				; Chiama la 0x1201 (L1201 ?)
			LD BC,0x0300			; Carica in BC il valore 0x0300
			ADD A,D					; Somma D ad A
			JP M,L1057				; Se negativo, passa a 0x1057
			INC D					; Incrementa D
			CP D					; Compara A con D
			JR NC,L1057				; Se CY=0, passa a 0x1057
			INC A					; Incrementa A
			LD B,A					; Copia A in B
			LD A,0x02				; Carica in A il valore 0x02
L1057		SUB 0x02				; Sottrae da A il valore 0x02
			POP HL					; Recupera HL dallo stack
			PUSH AF					; Salva AF nello stack
			CALL L1291				; Chiama la 0x1291 (L1291 ?)
			LD (HL),'0'				; Salva il valore 0x30 (carattere '0') in memoria puntata da (HL)
			CALL Z,INCHL			; Se zero, chiama la 0x09C9 (L09C9 INCHL)
			CALL L12A4				; Chiama la 0x12A4 (L12A4 ?)
L1066		DEC HL					; Decrementa HL
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CP '0'					; Compara A con il valore 0x30 (carattere '0')
			JR Z,L1066				; Se uguale, passa a 0x1066
			CP '.'					; Compara A con il valore 0x2E (carattere '.')
			CALL NZ,INCHL			; Se diverso da zero, chiama la 0x09C9 (L09C9 INCHL)
			POP AF					; Recupera AF dallo stack
			JR Z,L1093				; Se zero, passa a 0x1093
									;   continua con la 0x1074 (L1074 ?)

			;
			; Routine 0x1074
			;
L1074		PUSH AF					; Salva AF nello stack
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)		
			LD A,'"'				; Carica in A il valore 0x22 (carattere '"')
			ADC A,A					; Somma A ad A
			LD (HL),A				; Salva A in memoria puntata da (HL)
			INC HL					; Incremente HL
			POP AF					; Recupera AF dallo stack
			LD (HL),0x2B			; Salva il valore 0x2B (carattere '+') in memoria puntata da (HL)
			JP P,L1085				; Se positivo, passa a 0x1085
			LD (HL),'-'				; Salva il valore 0x2D (carattere '-') in memoria puntata da (HL)
			CPL						; Complementa A
			INC A					; Incrementa A
L1085		LD B,'/'				; Carica in A il valore 0x2F (carattere '/')
L1087		INC B					; Incrementa B
			SUB 0x0A				; Sottrae da A il valore 0x0A
			JR NC,L1087				; Se CY=0, passa a 0x1087
			ADD A,':'				; Somma ad A il valore 0x3A (carattere ':')
			INC HL					; Incrementa HL
			LD (HL),B				; Salva B in memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD (HL),A				; Salva A in memoria puntata da (HL)
L1092		INC HL					; Incrementa HL
L1093		LD (HL),0x00			; Salva il valore 0x00 in memoria puntata da (HL)
			EX DE,HL				; Scambia DE ed HL
			LD HL,CONVBUFF			; Carica in HL il valore 0x4130 (CONVBUFF), inizio buffer
			RET						; Ritorna

			; 
			; Routine 0x109A
			;
L109A		INC HL					; Incrementa HL
			PUSH BC					; Salva BC nello stack
			CP 0x04					; Compara A con il valore 0x04
			LD A,D					; Copia D in A
			JP NC,L1109				; Se CY=0, passa alla 0x1109 (L1109 ?)
			RRA						; Ruota A a destra di 1 bit
			JP C,LINEIN				; Se CY=1, passa alla 0x11A3 (L11A3 LINEIN)
			LD BC,0x0603			; Carica in BC il valore 0x0603
			CALL L1289				; Chiama la 0x1289 (L1289 ?)
			POP DE					; Recupera DE dallo stack
			LD A,D					; Copia D in A
			SUB 0x05				; Sottrae da A il valore 0x05
			CALL P,L1269			; Se positivo, chiama la 0x1269 (L1269 FILLZR)
			CALL L132F				; Chiama la 0x132F (L132F ?)
L10B6		LD A,E					; Copia E in A
			OR A					; Esegue OR di A
			CALL Z,L092F			; Se zero, chiama la 0x092F (L092F DECHL)
			DEC A					; Decremeta A
			CALL P,L1269			; Se positivo, chiama la 0x1269 (L1269 FILLZR)
			;
L10BF		PUSH HL					; Salva HL nello stack
			CALL L0FF5				; Chiama la 0x0FF5 (L0FF5 ?)
			POP HL					; Recupera HL dallo stack
			JR Z,L10C8				; Se zero, passa a 0x10C8
			LD (HL),B				; Salva B in memoria puntata da (HL)
			INC HL					; Incrementa HL
L10C8		LD (HL),0x00			; Azzera memoria puntata da (HL
			LD HL,0x412F			; Carica in HL il valore 0x412F
L10CD		INC HL					; Incrementa HL
L10CE		LD A,(NXTOPR)			; Carica in A memoria puntata da (0x40F3) NXTOPR
			SUB L					; Sottrae L da A
			SUB D					; Sottrae D da A
			RET Z					; Se zero, ritorna
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CP ' '					; Compara A con il valore 0x20 (carattere ' ')
			JR Z,L10CD				; Se uguale, passa a 0x10CD
			CP '*'					; Compara A con il valore 0x2A (carattere '*')
			JR Z,L10CD				; Se uguale, passa a 0x10CD
			DEC HL					; Decrementa HL
			PUSH HL					; Salva HL nello stack
L10DF		PUSH AF					; Salva AF nello stack
			LD BC,L10DF				; Carica in BC il valore 0x10DF
			PUSH BC					; Salva BC nello stack
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			CP '-'					; Compara A con il valore 0x2D (carattere '-')
			RET Z					; Se zero, ritorna
			CP '+'					; Compara A con il valore 0x2B (carattere '+')
			RET Z					; Se zero, ritorna
			CP '$'					; Compara A con il valore 0x24 (carattere '$')
			RET Z					; Se zero, ritorna
			POP BC					; Recupera BC dallo stack
			CP '0'					; Compara A con il valore 0x30 (carattere '0')
			JR NZ,L1102				; Se diverso, passa a 0x1102 (L1102)
			INC HL					; Incrementa HL
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			JR NC,L1102				; Se CY=0, passa a 0x1102 (L1102)
			DEC HL					; Decremeta HL
			.BYTE 0x01				; Esegye LD BC,0x772B, skip di DEC HL e LD (HL),A
									;   continua con 0x10FB (L10FB)
									;
L10F9		DEC HL					; Decrementa HL
			LD (HL),A				; Salva A in memoria puntata da (HL)
L10FB		POP AF					; Recupera AF dallo stack
			JR Z,L10F9				; Se zero, passa a 0x10F9, ciclo
			POP BC					; Recupera BC dallo stack
			JP L10CE				; Passa a 0x10CE
			;
L1102		POP AF					; Recupera AF dallo stack
			JR Z,L1102				; Se zero, passa a 0x1102, ciclo
			POP HL					; Recupera HL dallo stack
			LD (HL),'%'				; Salva il valore 0x25 (carattere '%') in memoria puntata da (HL)
			RET						; Ritorna

			;
			; Routine 0x1109
			;
L1109		PUSH HL					; Salva HL nello stack
			RRA						; Ruota A a destra di 1 bit
			JP C,L11AA				; Se CY=1, passa alla 0x11AA (L11AA ?)
			JR Z,L1124				; Se zero, passa alla 0x1124 (L1124 ?)
			LD DE,L1384				; Carica in DE il valore 0x1384 (puntatore a L1384)
			CALL L0A49				; Chiama la 0x0A49 (L0A49 ?)
			LD D,0x10				; Carica in D il valore 0x10	
			JP M,L1132				; Se negativo, passa a 0x1132 (L1132 ?)
L111B		POP HL					; Recupera HL dallo stack
			POP BC					; Recupera BC dallo stack
			CALL NUMASC				; Chiama la 0x0FBD (L0FBD NUMASC)
			DEC HL					; Decrementa HL
			LD (HL),'%'				; Salva il valore 0x25 (carattere '%') in memoria puntata da (HL)
			RET						; Ritorna

			;
			; Routine 0x1124
			;
L1124		LD BC,0xB60E			; Carica in BC il valore 0x0B60E
			LD DE,0x1BCA			; Carica in DE il valore 0x1BCA
			CALL CMPNUM				; Chiama la 0x0A0C (L0A0C CMPNUM)
			JP P,L111B				; Se positivo, passa alla 0x111B (L111B ?)
			LD D,0x06				; Carica in D il valore 0x06
L1132		CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)
			CALL NZ,L1201			; Se diverso da zero, chiama la 0x1201 (L1201 ?)
			POP HL					; Recupera HL dallo stack
			POP BC					; Recupera BC dallo stack
			JP M,L1157				; Se negativo, passa a 0x1157 (L1157 ?)
			PUSH BC					; Salva BC nello stack
			LD E,A					; Copia A in E
			LD A,B					; Copia B in A
			SUB D					; Sottrae D da A
			SUB E					; Sottrae E da A
			CALL P,L1269			; Se positivo, chiama la 0x1269 (L1269 FILLZR)
			CALL L127D				; Chiama la 0x127D (L127D ?)
			CALL L12A4				; Chiama la 0x12A4 (L12A4 ?)
			OR E					; Esegue OR di A con E
			CALL NZ,L1277			; Se diverso da zero, chiama la 0x1277 (L1277 ?)
			OR E					; Esegue OR di A con E
			CALL NZ,L1291			; Se diverso da zero, chiama la 0x1291 (L1291 ?)
			POP DE					; Recupera DE dallo stack
			JP L10B6				; Passa a 0x10B6 (L10B6 ?)

			;
			; Routine 0x1157
			;
L1157		LD E,A					; Copia A in E
			LD A,C					; Copia C in A
			OR A					; Esegue OR di A
			CALL NZ,L0F16			; Se diverso da zero, passa a 0x0F16 (L0F16 DECA)
			ADD A,E					; Somma E ad A
			JP M,L1162				; Se negativo, passa a 0x1162
			XOR A					; Azzera A
L1162		PUSH BC					; Salva BC nello stack
			PUSH AF					; Salva AF nello stack
L1164		CALL M,L0F18			; Se negativo, chiama la 0x0F18 (L0F18 DIVTEN)
			JP M,L1164				; Se negativo, passa a 0x1164
			POP BC					; Recupera BC dallo stack
			LD A,E					; Copia E in A
			SUB B					; Sottrae B da A
			POP BC					; Recupera BC dallo stack
			LD E,A					; Copia A in E
			ADD A,D					; Somma D ad A
			LD A,B					; Copia B in A
			JP M,L117F				; Se negativo, passa a 0x117F
			SUB D					; Sottrae D da A
			SUB E					; Sottrae E da A
			CALL P,L1269			; Se positivo, passa a 0x1269 (L1269 FILLZR)
			PUSH BC					; Salva BC nello stack
			CALL L127D				; Chiama la 0x127D (L127D ?)
			JR L1190				; Passa alla 0x1190 (L1190 ?)
			;
L117F		CALL L1269				; Chiama la 0x1269 (L1269 FILLZR)
			LD A,C					; Copia C in A
			CALL L1294				; Chiama la 0x1294 (L1294 ?)
			LD C,A					; Copia A in C
			XOR A					; Azzera A
			SUB D					; Sottrae D da A
			SUB E					; Sottrae E da A
			CALL L1269				; Chiama la 0x1269 (L1269 FILLZR)
			PUSH BC					; Salva BC nello stack
			LD B,A					; Copia A in B
			LD C,A					; Copia A in C
L1190		CALL L12A4				; Chiama la 0x12A4 (L12A4 ?)
			POP BC					; Recupera BC dallo stack
			OR C					; Esegue OR di A con C
			JR NZ,L119A				; Se diverso da zero, passa a 0x119A
			LD HL,(NXTOPR)			; Carica in HL da memoria puntata da (0x40F3) NXTOPR
L119A		ADD A,E					; Somma E ad A
			DEC A					; Decrementa A
			CALL P,L1269			; Chiama la 0x1269 (L1269 FILLZR)
			LD D,B					; Copia B in D
			JP L10BF				; Passa alla 0x10BF (L10BF EXPLP)

			;
			; Routine 0x11A3 - LINEIN
			;
LINEIN		PUSH HL					; Salva HL nello stack
			PUSH DE					; Salva DE nello stack
			CALL L0ACC				; Chiama la 0x0ACC (L0ACC ?)
			POP DE					; Recupera DE dallo stack
			XOR A					; Azzera A
L11AA		JP Z,L11B0				; Se zero, passa a 0x11B0
			LD E,ECOD10				; Carica in E il valore 0x10 (Codice errore Subscript Out Of Range)
			.BYTE 0x01				; Esegue LD BC,0x061Em skip LD E,0x06
									;   continua con 0x11B2
			;
L11B0		LD E,ECOD06				; Carica in E il valore 0x06 (Codice errore Out Of Data)
L11B2		CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)
			SCF						; CY=1
			CALL NZ,L1201			; Se diverso da zero, chiama la 0x1201 (L1201 ?)
			POP HL					; Recupera HL dallo stack
			POP BC					; Recupera BC dallo stack
			PUSH AF					; Salva AF nello stack
			LD A,C					; Copia C in A
			OR A						; Esegue OR di A
			PUSH AF					; Salva AF nello stack
			CALL NZ,L0F16			; Se diverso da zero, chiama la 0x0F16 (L0F16 DECA)
			ADD A,B					; Somma B ad A
			LD C,A					; Copia A in C
			LD A,D					; Copia D in A
			AND 0x04				; Esegue AND di A con il valore 0x04
			CP 0x01					; Compara A con il valore 0x01
			SBC A,A					; Sottrae A da A
			LD D,A					; Copia A in D
			ADD A,C					; Somma C ad A
			LD C,A					; Copia A in C
			SUB E					; Sottrae E da A
			PUSH AF					; Salva AF nello stack
			PUSH BC					; Salva BC nello stack
L11D0		CALL M,L0F18			; Se negativo, chiama la 0x0F18 (L0F18 DIVTEN)
			JP M,L11D0				; Se negativo, passa a 0x11D0
			POP BC					; Recupera BC dallo stack
			POP AF					; Recupera AF dallo stack
			PUSH BC					; Salva BC nello stack
			PUSH AF					; Salva AF nello stack
			JP M,L11DE				; Se negativo, passa a 0x11DE
			XOR A					; Azzera A
L11DE		CPL						; Complementa A
			INC A					; Incrementa A		
			ADD A,B					; Somma B ad A
			INC A					; Incrementa A
			ADD A,D					; Somma D ad A
			LD B,A					; Copia A in B
			LD C,0x00				; Azzera C
			CALL L12A4				; Chiama la 0x12A4 (L12A4 ?)
			POP AF					; Recupera AF dallo stack
			CALL P,L1271			; Se positivo, passa alla 0x1271 (L1271 ?)
			POP BC					; Recupera BC dallo stack
			POP AF					; Recupera AF dallo stack
			CALL Z,L092F			; Se zero, chiama la 0x092F (L092F DECHL)
			POP AF					; Recupera AF dallo stack
			JR C,L11F8				; Se CY=1, passa a 0x11F8 
			ADD A,E					; Somma E ad A
			SUB B					; Sottrae B da A
			SUB D					; Sottrae D da A
L11F8		PUSH BC					; Salva BC nello stack
			CALL L1074				; Chiama la 0x1074 (L1074 ?)
			EX DE,HL				; Scambia DE ed HL
			POP DE					; Recupera DE dallo stack
			JP L10BF				; Passa alla 0x10BF (L10BF ?)
			;
L1201		PUSH DE					; Salva DE nello stack
			XOR A					; Azzera A
			PUSH AF					; Salva AF nello stack
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			JP PO,L1222				; Se po, passa a 0x1222
L1208		LD A,(FPEXP)			; Carica in A da memoria puntata da (0x4124) FPEXP
			CP 0x91					; Compara A con il valore 0x91
			JP NC,L1222				; Se CY=0, passa a 0x1222
			LD DE,ZERO				; Carica in DE il valore 0x1364 (puntatore a ZERO)
			LD HL,UNK05				; Carica in HL il valore 0x4127 (puntatore a UNK05)
			CALL CPYVDEHL				; Chiama la 0x09D3 (L09D3 CPYVDEHL)
			CALL L0DA1				; Chiama la 0x0DA1 (L0DA1 ?)
			POP AF					; Recupera AF dallo stack
			SUB 0x0A				; Sottrae da A il valore 0x0A
			PUSH AF					; Salva AF nello stack
			JR L1208				; Passa a 0x1208
			;
L1222		CALL L124F				; Chiama la 0x124F (L124F RNGTST)
L1225		RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			JR NC,L1233				; Se CY=0, passa a 0x1233
			LD BC,0x9143			; Carica in BC il valore 0x9143			; BCDE - 99999.9
			LD DE,0x4FF9			; Carica in DE il valore 0x4FF9
			CALL CMPNUM				; Chiama la 0x0A0C (L0A0C CMPNUM)		; Compare numbers
			JR L1239				; Passa a 0x1239
L1233		LD DE,L136C				; Carica in DE il valore 0x136C (puntatore a L136C)
			CALL L0A49				; Chiama la 0x0A49 (L0A49 ?)			
L1239		JP P,L124B				; Se positivo, passa a 0x124B			; > 99999.9 - Sort it out
			POP AF					; Recupera AF dallo stack				; Restore count
			CALL MULTEN				; Chiama la 0x0F0B (L0F0B MULTEN)		; Multiply by ten
			PUSH AF					; Salva AF nello stack					; Re-save count
			JR L1225				; Passa a 0x1225						; Test it again

			;
			; Routine 0x1243 - GTSIXD
			;
L1243		POP AF					; Recupera AF dallo stack
			CALL L0F18				; Chiama la 0x0F18 (L0F18 DIVTEN)
			PUSH AF					; Salva AF nello stack
			CALL L124F				; Chiama la 0x124F (L124F RNGTST)
L124B		POP AF					; Recupera AF dallo stack
			OR A					; Esegue OR di A
			POP DE					; Recupera DE dallo stack
			RET						; Ritorna

			;
			; Routine 0x124F - RNGTST
			;
L124F		RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			JP PE,L125E				; Se pe, passa a 0x125E
			LD BC,0x9474			; Carica in BC Il valore 0x9474				; BCDE = 999999.0
			LD DE,0x23F8			; Carica in DE Il valore 0x23F8
			CALL CMPNUM				; Chiama la 0x0A0C (L0A0C CMPNUM)
			JR L1264				; Passa a 0x1264
L125E		LD DE,L1374				; Carica in DE il valore 0x1374 (puntatore a L1374)
			CALL L0A49				; Chiama la 0x0A49 (L0A49 ?)
L1264		POP HL					; Recupera HL dallo stack
			JP P,L1243				; Se positivo, passa a 0x1243 (L1243 GTSIXD)
			JP (HL)					; Passa a indirizzo puntato da (HL)

			;
			; Routine 0x1269 - FILLZR  Salva in (HL) A caratteri '0' 
			;    Input: HL destinazione, A contatore '0'
			;
L1269		OR A					; Esegue OR di A
L126A		RET Z					; Se zero, ritorna
			DEC A					; Decrementa A
			LD (HL),0x30			; Salva il valore 0x30 (carattere '0') in memoria puntata da (HL)
			INC HL					; Incrementa HL
			JR L126A				; Passa a 0x126A
			
			;
			; Routine 0x1271
			;
L1271		JR NZ,L1277				; Se diverso da zero, passa a 0x1277
L1273		RET Z					; Se zero, ritorna
			CALL L1291				; Chiama la 0x1291 (L1291 ?)
L1277		LD (HL),0x30			; Salva il valore 0x30 (carattere '0') in memoria puntata da (HL)
			INC HL					; Incrementa HL
			DEC A					; Decrementa A
			JR L1273				; Passa a 0x1273

			;
			; Routine 0x127D
			;
L127D		LD A,E					; Copia E in A
			ADD A,D					; Somma D ad A
			INC A					; Incrementa A
			LD B,A					; Copia A in B
			INC A					; Incrementa A
L1282		SUB 0x03				; Sottrae da A il valore 0x03
			JR NC,L1282				; Se CY=0, passa a 0x1282
			ADD A,0x05				; Somma ad A il valore 0x05
			LD C,A					; Copia A in C
									;   continua con 0x1289 (L1289 ?)

			;
			; Routine 0x1289
			;
L1289		LD A,(CUROPR)			; Carica in A da memoria puntata da (0x40D8) CUROPR
			AND 0x40				; Esegue AND di A con il valore 0x40
			RET NZ					; Se diverso da zero, ritorna
			LD C,A					; Copia A in C
			RET						; Ritorna

			;
			; Routine 0x1291
			;
L1291		DEC B					; Decrementa B
			JR NZ,L129C				; Se diverso da zero, passa a 0x129C (L129C ?)
L1294		LD (HL),'.'			; Salva il valore 0x2E (carattere '.') in memoria puntata da (HL)
			LD (NXTOPR),HL			; Salva HL in memoria puntata da (0x40F3) NXTOPR
			INC HL					; Incrementa HL
			LD C,B					; Copia B in C
			RET						; Ritorna

			;
			; Routine 0x129C
			;
L129C		DEC C					; Decrementa C
			RET NZ					; Se diverso da zero, ritorna
			LD (HL),','				; Salva il valore 0x2C (carattere ',') in memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD C,0x03				; Carica in C il valore 0x03
			RET						; Ritorna

			;
			; Routine 0x12A4
			;
L12A4		PUSH DE					; Salva DE nello stack
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			JP PO,L12EA				; Se po, passa a 0x12EA
			PUSH BC					; Salva BC nello stack
			PUSH HL					; Salva HL nello stack
			CALL L09FC				; Chiama la 0x09FC (L09FC MVFPSTMP)
			LD HL,L137C				; Carica in HL il valore 0x137C (puntatore a L137C)
			CALL L09F7				; Chiama la 0x09F7 (L09F7 ?)
			CALL L0C77				; Chiama la 0x0C77 (L0C77 ?)
			XOR A					; Azzera A
			CALL L0B7B				; Chiama la 0x0B7B (L0B7B ?)
			POP HL					; Recupera HL dallo stack
			POP BC					; Recupera BC dallo stack
			LD DE,0x138C			; Carica in DE il valore 0x138C
			LD A,0x0A				; Carica in A il valore 0x0A
L12C2		CALL L1291				; Chiama la 0x1291 (L1291 ?)
			PUSH BC					; Salva BC nello stack
			PUSH AF					; Salva AF nello stack
			PUSH HL					; Salva HL nello stack
			PUSH DE					; Salva DE nello stack
			LD B,0x2F				; Carica in B il valore 0x2F (caratter '/')
L12CB		INC B					; Incrementa B
			POP HL					; Recupera HL dallo stack
			PUSH HL					; Salva HL nello stack
			CALL L0D48				; Chiama la 0x0D48 (L0D48 ?)
			JR NC,L12CB				; Se CY=0, passa a 0x12CB
			POP HL					; Recupera HL dallo stack
			CALL L0D36				; Chiama la 0x0D36 (L0D36 ?)
			EX DE,HL				; Scambia DE ed HL
			POP HL					; Recupera HL dallo stack
			LD (HL),B				; Salva B in memoria puntata da (HL)
			INC HL					; Incrementa HL
			POP AF					; Recupera AF dallo stack
			POP BC					; Recupera BC dallo stack
			DEC A					; Decrementa A
			JR NZ,L12C2				; Se diverso da zero, passa a 0x12C2
			PUSH BC					; Salva BC nello stack
			PUSH HL					; Salva HL nello stack
			LD HL,TDBL1				; Carica in HL il valore 0x411D (puntatore a TDBL1)
			CALL PHL2BCDEFP			; Chiama la 0x09B1 (L09B1 PHL2BCDEFP)
			JR L12F6				; Passa a 0x12F6
L12EA		PUSH BC					; Salva BC nello stack
			PUSH HL					; Salva HL nello stack
			CALL ROUND				; Chiama la 0x0708 (L0708 ROUND)
			INC A					; Incrementa A
			CALL FP2INT				; Chiama la 0x0AFB (L0AFB FP2INT)
			CALL BCDE2FPR			; Chiama la 0x09B4 (L09B4 BCDE2FPR)
L12F6		POP HL					; Recupera HL dallo stack
			POP BC					; Recupera BC dallo stack
			XOR A					; Azzera A
			LD DE,TABPOW			; Carica in DE il valore 0x13D2 (puntatore a tabella TABPOW)
L12FC		CCF						; Inverte CY
			CALL L1291				; Chiama la 0x1291 (L1291 ?)
			PUSH BC					; Salva BC nello stack
			PUSH AF					; Salva AF nello stack
			PUSH HL					; Salva HL nello stack
			PUSH DE					; Salva DE nello stack
			CALL FPR2BCDE			; Chiama la 0x09BF (L09BF FPR2BCDE)
			POP HL					; Recupera HL dallo stack
			LD B,0x2F				; Carica in B il valore 0x2F (carattere '/')
L130A		INC B					; Incrementa B
			LD A,E					; Copia E in A
			SUB (HL)				; Sottrae da A memoria puntata da (HL)
			LD E,A					; Copia A in E
			INC HL					; Incrementa HL
			LD A,D					; Copia D in A
			SBC A,(HL)				; Sottrae da A memoria puntata da (HL)
			LD D,A					; Copia A in D
			INC HL					; Incrementa HL
			LD A,C					; Copia C in A
			SBC A,(HL)				; Sottrae da A memoria puntata da (HL)
			LD C,A					; Copia A in C
			DEC HL					; Decrementa HL
			DEC HL					; Decrementa HL
			JR NC,L130A				; Se CY=0, passa a 0x130A
			CALL L07B7				; Chiama la 0x07B7 (L07B7 SUM24)
			INC HL					; Incrementa HL
			CALL BCDE2FPR			; Chiama la 0x09B4 (L09B4 BCDE2FPR)
			EX DE,HL				; Scambia DE ed HL
			POP HL					; Recupera HL dallo stack
			LD (HL),B				; Salva B in memoria puntata da (HL)
			INC HL					; Incrementa HL
			POP AF					; Recupera AF dallo stack
			POP BC					; Recupera BC dallo stack
			JR C,L12FC				; Se CY=1, passa a 0x12FC
			INC DE					; Incrementa DE
			INC DE					; Incrementa DE
			LD A,0x04				; Carica in A il valore 0x04
			JR L1335				; Passa a 0x1335
			;
L132F		PUSH DE					; Salva DE nello stack
			LD DE,0x13D8			; Carica in DE il valore 0x13D8
			LD A,0x05				; Carica in A il valore 0x05
L1335		CALL L1291				; Chiama la 0x1291 (L1291 ?)
			PUSH BC					; Salva BC nello stack
			PUSH AF					; Salva AF nello stack
			PUSH HL					; Salva HL nello stack
			EX DE,HL				; Scambia DE ed HL
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			PUSH BC					; Salva BC nello stack
			INC HL					; Incrementa HL
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			EX DE,HL				; Scambia DE ed HL
			LD HL,(FPREG)			; Carica in HL da memoria puntata da (0x4121) FPREG
			LD B,0x2F				; Carica in B il valore 0x2F (carattere '/')
L1348		INC B					; Incrementa B
			LD A,L					; Copia L in A
			SUB E					; Sottrae E da A
			LD L,A					; Copia A in L
			LD A,H					; Copia H in A
			SBC A,D					; Sottrae D da A
			LD H,A					; Copia A in H
			JR NC,L1348				; Se CY=0, passa a 0x1348
			ADD HL,DE				; Somma DE ad HL
			LD (FPREG),HL			; Salva HL in memoria puntata da (0x4121)
			POP DE					; Recupera DE dallo stack
			POP HL					; Recupera HL dallo stack
			LD (HL),B				; Salva B in memoria puntata da (HL)
			INC HL					; Incrementa HL
			POP AF					; Recupera AF dallo stack
			POP BC					; Recupera BC dallo stack
			DEC A					; Decrementa A
			JR NZ,L1335				; Se diverso da zero, passa a 0x1335
			CALL L1291				; Chiama la 0x1291 (L1291 ?)
			LD (HL),A				; Salva A in memoria puntata da (HL)
			POP DE					; Recupera DE dallo stack
			RET						; Ritorna

			;
			; Valori FP notevoli
			;
ZERO		.BYTE 0x00, 0x00, 0x00, 0x00		; 0.0
			.BYTE 0xF9, 0x02, 0x15, 0xA2
L136C		.BYTE 0xFD, 0xFF, 0x9F, 0x31
			.BYTE 0xA9, 0x5F, 0x63, 0xB2
L1374		.BYTE 0xFE, 0xFF, 0x03, 0xBF
			.BYTE 0xC9, 0x1B, 0x0E, 0xB6
L137C		.BYTE 0x00, 0x00, 0x00, 0x00

			;
			; Valori FP notevoli
			;
HALF		.BYTE 0x00, 0x00, 0x00, 0x80		; 0.5

L1384		.BYTE 0x00, 0x00, 0x04, 0xBF		
			.BYTE 0xC9, 0x1B, 0x0E, 0xB6      
			.BYTE 0x00, 0x80, 0xC6, 0xA4      
			.BYTE 0x7E, 0x8D, 0x03, 0x00        
			.BYTE 0x40, 0x7A, 0x10, 0xF3      
			.BYTE 0x5A, 0x00, 0x00, 0xA0         					
			.BYTE 0x72, 0x4E, 0x18, 0x09         
			.BYTE 0x00, 0x00, 0x10, 0xA5 
			.BYTE 0xD4, 0xE8, 0x00, 0x00 
			.BYTE 0x00, 0xE8, 0x76, 0x48 
			.BYTE 0x17, 0x00, 0x00, 0x00 
			.BYTE 0xE4, 0x0B, 0x54, 0x02 
			.BYTE 0x00, 0x00, 0x00, 0xCA 
			.BYTE 0x9A, 0x3B, 0x00, 0x00 
			.BYTE 0x00, 0x00, 0xE1, 0xF5 
			.BYTE 0x05, 0x00, 0x00, 0x00 
			.BYTE 0x80, 0x96, 0x98, 0x00 
			.BYTE 0x00, 0x00, 0x00, 0x40 
			.BYTE 0x42, 0x0F, 0x00, 0x00 
			.BYTE 0x00, 0x00        

			;
			; Tabella TABPOW
			;
TABPOW		.BYTE 0xA0, 0x86, 0x01			; 100000
			.BYTE 0x10, 0x27, 0x00			;  10000
			.BYTE 0x10, 0x27   				;  10000
			.BYTE 0xE8, 0x03				;   1000
			.BYTE 0x64, 0x00				;    100
			.BYTE 0x0A, 0x00				;     10
			.BYTE 0x01, 0x00				;      1

			; Routine 0x13E2 - INVSGN2  Inverte segno
			;
L13E2		LD HL,0x0982			; Carica in HL il valore 0x0982 (L0982 INVSGN)
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			JP (HL)					; Passa a indirizzo puntato da (HL)

			;
			; Routine 0x13E7 - SQR
			;
SQR			CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)				; Put value on stack
			LD HL,0x1380			; Carica in HL il valore 0x1380					; Set power to 1/2
			CALL PHL2BCDEFP			; Chiama la 0x09B1 (L09B1 PHL2BCDEFP)			; Move 1/2 to FPREG
			JR L13F5				; Passa alla 0x13F5 (L013F5 POWER)				; Compute the power

			;
			; Routine 0x13F2
			;
L13F2		CALL CSNG				; Chiama la 0x0AB1 (L0AB1 CSNG)
									;   continua con la 0x13F5 (L1305 POWER)

			;
			; Routine 0x13F5 - POWER
			;
L13F5		POP BC					; Recupera BC dallo stack							; Get base
			POP DE					; Recupera DE dallo stack
			CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)					; Test sign of power
			LD A,B					; Copia B in A										; Get exponent of base
			JR Z,EXP				; Se zero, passa a 0x1439 (L1439 EXP)				; Make result 1 if zero
			JP P,L1404				; Se positivo, passa a 0x1404						; Positive base - Ok
			OR A					; Esegue OR di A									; Zero to negative power?
			JP Z,DZERR				; Se zero, passa a 0x199A (L199A DZERR)				; Yes - ?/0 Error
L1404		OR A					; Esegue OR di A									; Base zero?
			JP Z,SAVAEXP			; Se zero, passa a 0x0779 (L0779 SAVAEXP)			; Yes - Return zero
			PUSH DE					; Salva DE nello stack								; Save base
			PUSH BC					; Salva BC nello stack
			LD A,C					; Copia C in A										; Get MSB of base
			OR 0x7F					; Esegue OR di A con il valore 0x7F					; Get sign status
			CALL FPR2BCDE			; Chiama la 0x09BF (L09BF FPR2BCDE)					; Move power to BCDE
			JP P,L1421				; Se positivo, passa a 0x1421						; Positive base - Ok
			PUSH DE					; Salva DE nello stack								; Save power
			PUSH BC					; Salva BC nello stack
			CALL L0B40				; Chiama la 0x0B40 (L0B40 ?)						; Get integer of power
			POP BC					; Recupera BC dallo stack							; Restore power
			POP DE					; Recupera DE dallo stack
			PUSH AF					; Salva AF nello stack								; MSB of base
			CALL CMPNUM				; Chiama la 0x0A0C (L0A0C CMPNUM)					; Power an integer?
			POP HL					; Recupera HL dallo stack							; Restore MSB of base
			LD A,H					; Copia H in A										; but don't affect flags
			RRA     				; Ruota A a destra di 1 bit							; Exponent odd or even?
L1421		POP HL					; Recupera HL dallo stack							; Restore MSB and exponent
			LD (FPREGMSB),HL		; Salva HL in memoria puntata da (0x4123) FPREGMSB	; Save base in FPREG
			POP HL					; Recupera HL dallo stack							; LSBs of base
			LD (FPREG),HL			; Salva HL in memoria puntata da (0x4121)			; Save in FPREG
			CALL C,L13E2			; Se CY=1, chiama la 0x13E2 (L13E2 INVSGN2)			; Odd power - Negate result
			CALL Z,L0982			; Se zero, chiama la 0x0982 (L0982 INVSGN)			; Negative base - Negate it
			PUSH DE					; Salva DE nello stack								; Save power
			PUSH BC					; Salva BC nello stack
			CALL LOG				; Chiama la 0x0809 (L0809 LOG)						; Get LOG of base
			POP BC					; Recupera BC dallo stack							; Restore power
			POP DE					; Recupera DE dallo stack
			CALL FPMULT				; Chiama la 0x0847 (L0847 FPMULT)					; Multiply LOG by power

			; 
			; Routine 0x1439 - EXP
			;
EXP			CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)									; Put value on stack
			LD BC,0x8138			; Carica in BC il valore 0x8138										; BCDE = 1/Ln(2) 1.442695
			LD DE,0xAA3B			; Carica in BC il valore 0xAA3B
			CALL FPMULT				; Chiama la 0x0847 (L0847 FPMULT Moltiplica BCDE per FPREG)			; Multiply value by 1/LN(2)
			LD A,(FPEXP)			; Carica in A memoria puntata da (0x4124) FPEXP						; Get exponent
			CP 0x88					; Compara A con il valore 0x88										; Is it in range?
			JP NC,L0931				; Se CY=0, passa a 0x0931 (L0931 ?)									; No - Test for overflow
			CALL L0B40				; Chiama la 0x0B40 (L0B40 ?)										; Get INT of FPREG
			ADD A,0x80				; Somma ad A il valore 0x80											; For excess 128
			ADD A,0x02				; Somma ad A il valore 0x02											; Exponent > 126?
			JP C,L0931				; Se CY=1, passa a 0x0931 (L0931 ?)									; Yes - Test for overflow
			PUSH AF					; Salva AF nello stack												; Save scaling factor
			LD HL,UNITY				; Carica in HL il valore 0x07F8 (Puntatore a UNITY)					; Point to 1.0
			CALL ADDPHL				; Chiama la 0x070B (L070B ADDPHL)									; Add 1 to FPREG
			CALL MULLN2				; Chiama la 0x0841 (L0841 MULLN2)									; Multiply by LN(2)
			POP AF					; Recupera AF dallo stack											; Restore scaling factor
			POP BC					; Recupera BC dallo stack											; Restore exponent
			POP DE					; Recupera DE dallo stack
			PUSH AF					; Salva AF nello stack												; Save scaling factor
			CALL FPSUB				; Chiama la 0x0713 (L0713 FPSUB)									; Subtract exponent from FPREG
			CALL L0982				; Chiama la 0x0982 (L0982 INVSGN)									; Negate result
			LD HL,EXPTAB			; Carica in HL il valore 0x1479 (puntatore a EXPTAB)				; Coefficient table
			CALL L14A9				; Chiama la 0x14A9 (L14A9 SMSER1)									; Sum the series
			LD DE,0x0000			; Azzera DE															; Zero LSBs
			POP BC					; Recupera BC dallo stack											; Scaling factor
			LD C,D					; Copia D in C														; Zero MSB
			JP FPMULT				; Passa alla 0x0847 (L0847 FPMULT)									; Scale result to correct value

			;
			; Tabella EXPTAB
			;
EXPTAB 		.BYTE 0x08						; EXPTAB (8 elementi)
			.BYTE 0x40, 0x2E, 0x94, 0x74	; -1/7! (-1/5040)
			.BYTE 0x70, 0x4F, 0x2E, 0x77	;  1/6! ( 1/720)
			.BYTE 0x6E, 0x02, 0x88, 0x7A	; -1/5! (-1/120)
			.BYTE 0xE6, 0xA0, 0x2A, 0x7C	;  1/4! ( 1/24)
			.BYTE 0x50, 0xAA, 0xAA, 0x7E	; -1/3! (-1/6)
			.BYTE 0xFF, 0xFF, 0x7F, 0x7F	;  1/2! ( 1/2)
			.BYTE 0x00, 0x00, 0x80, 0x81	; -1/1! (-1/1)
			.BYTE 0x00, 0x00, 0x00, 0x81	;  1/0! ( 1/1)

			; 
			; Routine 0x149A - SUMSER
			;
L149A		CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)								; Put FPREG on stack
			LD DE,0x0C32			; Carica in DE il valore 0x0C32									; Multiply by "X"
			PUSH DE					; Salva DE nello stack											; To be done after
			PUSH HL					; Salva HL nello stack											; Save address of table
			CALL FPR2BCDE			; Chiama la 0x09BF (L09BF FPR2BCDE)								; Move FPREG to BCDE
			CALL FPMULT				; Chiama la 0x0847 (L0847 FPMULT Moltiplica BCDE per FPREG)		; Square the value
			POP HL					; Recupera HL dallo stack										; Restore address of table
L14A9		CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)								; Put value on stack
			LD A,(HL)				; Carica in A da memoria puntata da (HL)						; Get number of coefficients
			INC HL					; Incrementa HL													; Point to start of table
			CALL PHL2BCDEFP			; Chiama la 0x09B1 (L09B1 PHL2BCDEFP)							; Move coefficient to FPREG
			.BYTE 0x06				; Esegue LD B,0xF1, skip POP AF
									;  continua con 0x14B3 (L14B3)
L14B2		POP AF					; Recupera AF dallo stack
L14B3		POP BC					; Recupera BC dallo stack										; Restore count
			POP DE					; Recupera DE dallo stack										; Restore number
			DEC A					; Decrementa A													; Cont coefficients
			RET Z					; Se zero, ritorna												; All done
			PUSH DE					; Salva DE nello stack											; Save number
			PUSH BC					; Salva BC nello stack																
			PUSH AF					; Salva AF nello stack											; Save count
			PUSH HL					; Salva HL nello stack											; Save address in table
			CALL FPMULT				; Chiama la 0x0847 (L0847 FPMULT Moltiplica BCDE per FPREG)		; Multiply FPREG by BCDE
			POP HL					; Recupera HL dallo stack										; Restore address in table
			CALL PHL2BCDE			; Chiama la 0x09C2 (L09C2 PHL2BCDE)								; Number at HL to BCDE
			PUSH HL					; Salva HL nello stack											; Save address in table
			CALL FPADD				; Chiama la 0x0716 (L0716 FPADD)								; Add coefficient to FPREG
			POP HL					; Recupera HL dallo stack										; Restore address in table
			JR L14B2				; Passa a 0x14B2												; More coefficients

			;
			; Routine 0x14C9 - RND
			;
RND			CALL CINT				; Chiama la 0x0A7F (L0A7F CINT)
			LD A,H					; Copia H in A
			OR A					; Esegue OR di A
			JP M,IFERR				; Se negativo, passa alla 0x1E4A (L1E4A IFERR)
			OR L					; Esegue OR di A con L
			JP Z,L14F0				; Se zero, passa a 0x14F0 (L14F0 ?) 
			PUSH HL					; Salva HL nello stack
			CALL L14F0				; Chiama la 0x14F0 (L14F0 ?) 
			CALL FPR2BCDE			; Chiama la 0x09BF (L09BF FPR2BCDE)
			EX DE,HL				; Scambia DE ed HL
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			PUSH BC					; Salva BC nello stack
			CALL L0ACF				; Chiama la 0x0ACF (L0ACF ?)
			POP BC					; Recupera BC dallo stack
			POP DE					; Recupera DE dallo stack
			CALL FPMULT				; Chiama la 0x0847 (L0847 FPMULT Moltiplica BCDE per FPREG)
			LD HL,UNITY				; Carica in HL il valore 0x07F8 (Puntatore a UNITY)
			CALL ADDPHL				; Chiama la 0x070B (L070B ADDPHL)
			JP L0B40				; Passa alla 0x0B40 (L0B40 ?)

			;
			; Routine 0x14F0
			;
L14F0		LD HL,0x4090			; Carica in HL il valore 0x4090
			PUSH HL					; Salva HL nello stack
			LD DE,0x0000			; Azzera DE
			LD C,E					; Copia E in C
			LD H,0x03				; Carica in H il valore 0x03
L14FA		LD L,0x08				; Carica in L il valore 0x08
L14FC		EX DE,HL				; Scambia DE ed HL
			ADD HL,HL				; Raddoppia HL
			EX DE,HL				; Scambia DE ed HL
			LD A,C					; Copia C in A
			RLA						; Ruota A a sinistra di 1 bit
			LD C,A					; Copia A in C
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			RLCA					; Ruota A a sinistra di 1 bit
			LD (HL),A				; Salva A in memoria puntata da (HL)
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			JP NC,L1516				; Se CY=0, passa a 0x1516
			PUSH HL					; Salva HL nello stack
			LD HL,(UNK01)			; Carica in HL da memoria puntata da (0x40AA) UNK01
			ADD HL,DE				; Somma DE ad HL
			EX DE,HL				; Scambia DE ed HL
			LD A,(UNK02)			; Carica in A da memoria puntata da (0x40AC) UNK02
			ADC A,C					; Somma C ad A
			LD C,A					; Copia A in C
			POP HL					; Recupera HL dallo stack
L1516		DEC L					; Decrementa L
			JP NZ,L14FC				; Se diverso da zero, passa a 0x14FC
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			INC HL					; Incrementa HL
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			DEC H					; Decrementa H
			JP NZ,L14FA				; Se diverso da zero, passa a 0x14FA
			POP HL					; Recupera HL dallo stack
			LD HL,0x0B065			; Carica in HL il valore 0xB065
			ADD HL,DE				; Somma DE ad HL
			LD (UNK01),HL			; Salva HL in memoria puntata da (0x40AA) UNK01
			CALL SVSNG				; Chiama la 0x0AEF (L0AEF SVSNG)
			LD A,0x05				; Carica in A il valore 0x05
			ADC A,C					; Somma C ad A
			LD (UNK02),A			; Salva A in memoria puntata da (0x40AC) UNK02
			EX DE,HL				; Scambia DE ed HL
			LD B,0x80				; Carica in B il valore 0x80
			LD HL,0x4125				; Carica in HL il valore 0x4125
			LD (HL),B				; Salva B in memoria puntata da (HL)
			DEC HL					; Decrementa HL
			LD (HL),B				; Salva B in memoria puntata da (HL)
			LD C,A					; Copia A in C
			LD B,0x00				; Azzera B
			JP L0765				; Passa alla 0x0765 (L0765 ?)

			;
			; Routine 0x1541 - COS
			;
COS			LD HL,HALFPI			; Carica in HL il valore 0x158B			; Point to PI/2 HALFPI
			CALL ADDPHL				; Chiama la 0x070B (L070B ADDPHL)		; Add it to PPREG
									; continua con la 0x1547 (L1547 SIN)
			
			;
			; Routine 0x1547 - SIN
			;			
SIN			CALL FPRONSTK			; Chiama la 0x09A4	(L09A4 FPRONSTK)	; Put angle on stack 
			LD BC,0x8349			; Carica in BC il valore 0x8349     ; BCDE = 2 PI
			LD DE,0x0FDB			; Carica in DE il valore 0x0FDB
			CALL BCDE2FPR			; Chiama la 0x09B4 (L09B4 BCDE2FPR)
			POP BC					; Recupera BC dallo stack
			POP DE					; Recupera DE dallo stack
			CALL DIVBCDE			; Chiama la 0x08A2 (L08A2 DIVBCDE)
			CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)
			CALL L0B40				; Chiama la 0x0B40 (L0B40 ?)
			POP BC					; Recupera BC dallo stack
			POP DE					; Recupera DE dallo stack
			CALL FPSUB				; Chiama la 0x0713 (L0713 FPSUB)
			LD HL,QUARTR			; Carica in HL il valore 0x158F (puntatore a QUARTR 1/4 FP)
			CALL SUBPHL				; Chiama la 0x0710 (L0710 SUBPHL)
			CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)
			SCF						; CY=1
			JP P,L1577				; Se positivo, passa a 0x1577
			CALL ROUND				; Chiama la 0x0708 (L0708 ROUND)
			CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)
			OR A					; Esegue OR di A
L1577		PUSH AF					; Salva AF nello stack
			CALL P,L0982			; Se positivo, chiama la 0x0982 (L0982 INVSGN)
			LD HL,QUARTR			; Carica in HL il valore 0x158F (puntatore a QUARTR 1/4 FP)
			CALL ADDPHL				; Chiama la 0x070B (L070B ADDPHL)
			POP AF					; Recupera AF dallo stack
			CALL NC,L0982			; Se CY=0, chiama la 0x0982 (L0982 INVSGN)
			LD HL,SINTAB			; Carica in HL il valore 0x1593 (puntatore a SINTAB)
			JP L149A				; Passa alla 0x149A (L149A SUMSER)

			;
			; Valori FP notevoli
			;
HALFPI 		.BYTE 0xDB, 0x0F, 0x49, 0x81		; HALFPI  PI/2  1.5708
QUARTR 		.BYTE 0x00, 0x00, 0x00, 0x7F		; QUARTR  1/4   0.25
			
			;
			; Tabella SINTAB
			;
SINTAB		.BYTE 0x05 						; SINTAB (5 elementi)
			.BYTE 0xBA, 0xD7, 0x1E, 0x86	; 39.711	
			.BYTE 0x64, 0x26, 0x99, 0x87	;-76.575
			.BYTE 0x58, 0x34, 0x23, 0x87	; 81.602
			.BYTE 0xE0, 0x5D, 0xA5, 0x86	;-41.342
			.BYTE 0xDA, 0x0F, 0x49, 0x83	;  6.2832

			;
			; Routine 0x15A8 - TAN
			;
TAN 		CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK), salva angolo nello stack		; Put angle on stack 
			CALL SIN				; Chiama la 0x1547 (L1547 SIN)										; Get SIN of angle
			POP BC					; Recupera BC dallo stack											; Restore angle
			POP HL					; Recupera HL dallo stack						                 
			CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK), salva SIN(angolo) nello stack	; Save SIN of angle  
			EX DE,HL				; Scambia DE ed HL													; BCDE = Angle
			CALL BCDE2FPR			; Chiama la 0x09B4 (L09B4 BCDE2FPR)									; Angle to FPREG
			CALL COS				; Chiama la 0x1541 (L1541 COS)										; Get COS of angle 
			JP DIV					; Chiama la 0x08A0 (L08A0 DIV), divide SIN(angolo)/COS(angolo)		; TAN = SIN / COS
			
			;
			; Routine 0x15BD - ATN
			;
ATN 		CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)						; Test sign of value
			CALL M,L13E2			; Se negativo, chiama la 0x13E2	(L13E2 INVSGN2)			; Negate result after if -ve
			CALL M,L0982			; Se negativo, chiama la 0x0982 (L0982 INVSGN)			; Negate value if -ve
			LD A,(FPEXP)			; Carica in A memoria puntata da (0x4124) FPEXP			; Get exponent
			CP 0x81					; Compara A con il valore 0x81							; Number less than 1?
			JR C,L15D9				; Se CY=1, passa a 0x15D9 (L15D9 ?)						; Yes - Get arc tangnt
			LD BC,0x8100			; Carica in BC il valore 0x8100							; BCDE = 1.0
			LD D,C					; Copia C in D
			LD E,C					; Copia C in E
			CALL DIVBCDE				; Chiama la 0x08A2 (L08A2 DIVBCDE)						; Get reciprocal of number DIVBCDE
			LD HL,SUBPHL			; Carica in HL il valore 0x0710	(punta a SUBPHL)		; Sub angle from PI/2
			PUSH HL					; Salva HL nello stack									; Save for angle > 1
L15D9		LD HL,ATNTAB			; Carica in HL il valore 0x15E3 (puntatore a ATNTAB)	; Coefficient table
			CALL L149A				; Chiama la 0x149A (L149A SUMSER)						; Evaluate sum of series 
			LD HL,HALFPI			; Carica in HL il valore 0x158B HALFPI					; PI/2 - angle in case > 1
			RET						; Ritorna												; Number > 1 - Sub from PI/2

			;
			; Tabella ATNTAB
			;
ATNTAB 		.BYTE 0x09						; ATNTAB (9 elementi)
			.BYTE 0x4A, 0xD7, 0x3B, 0x78	; 1/17
			.BYTE 0x02, 0x6E, 0x84, 0x7B	;-1/15
			.BYTE 0xFE, 0xC1, 0x2F, 0x7C	; 1/13
			.BYTE 0x74, 0x31, 0x9A, 0x7D	;-1/11
			.BYTE 0x84, 0x3D, 0x5A, 0x7D	; 1/9
			.BYTE 0xC8, 0x7F, 0x91, 0x7E	;-1/7       
			.BYTE 0xE4, 0xBB, 0x4C, 0x7E	; 1/5
			.BYTE 0x6C, 0xAA, 0xAA, 0x7F	;-1/3
			.BYTE 0x00, 0x00, 0x00, 0x81	; 1

			; 
			; Tabella TABFUNC
			; Entry-point funzioni
			;
TABFUNC		.DW SGN					; 'SGN'			
			.DW INT					; 'INT'			
			.DW ABS					; 'ABS'			
			.DW FRE					; 'FRE'			
			.DW INP					; 'INP'			
			.DW POS					; 'POS'			
			.DW SQR					; 'SQR'			
			.DW RND					; 'RND'
			.DW LOG					; 'LOG'			
			.DW EXP					; 'EXP'			
			.DW COS					; 'COS'			
			.DW SIN					; 'SIN'			
			.DW TAN					; 'TAN'			
			.DW ATN					; 'ATN'			
			.DW PEEK				; 'PEEK'		
			.DW SNERR2				; 'CVI'	
			.DW SNERR2				; 'CVS'	
			.DW SNERR2				; 'CVD'	
			.DW SNERR2				; 'EOF'	
			.DW SNERR2				; 'LOC'	
			.DW SNERR2				; 'LOF'	
			.DW SNERR2				;  'MKI$
			.DW SNERR2				; 'MKS$	
			.DW SNERR2				; 'MKD$	
			.DW CINT				; 'CINT'		
			.DW CSNG				; 'CSNG'		
			.DW CDBL				; 'CDBL'		
			.DW FIX 				; 'FIX'			
			.DW LEN 				; 'LEN'			
			.DW STR 				; 'STR$'		
			.DW VAL 				; 'VAL'			
			.DW ASC 				; 'ASC'			
			.DW CHR 				; 'CHR$'		
			.DW LEFT				; 'LEFT$'		
			.DW RIGHT				; 'RIGHT$'		
			.DW MID 				; 'MID$'		

			; Tabella keyword
			; Primo carattere di ogni stringa con bit7=1
			;
KWORDS		.TEXT 0x80+'E', 'ND'		; 
			.TEXT 0x80+'F', 'OR'		; 
			.TEXT 0x80+'R', 'ESET'		; 
			.TEXT 0x80+'S', 'ET'		; 
			.TEXT 0x80+'C', 'LS'		; 
			.TEXT 0x80+'C', 'MD'		; 
			.TEXT 0x80+'R', 'ANDOM'		; 
			.TEXT 0x80+'N', 'EXT'		; 
			.TEXT 0x80+'D', 'ATA'		; 
			.TEXT 0x80+'I', 'NPUT'		; 
			.TEXT 0x80+'D', 'IM'		; 
			.TEXT 0x80+'R', 'EAD'		; 
			.TEXT 0x80+'L', 'ET'		; 
			.TEXT 0x80+'G', 'OTO'		; 
			.TEXT 0x80+'R', 'UN'		; 
			.TEXT 0x80+'I', 'F'			; 
			.TEXT 0x80+'R', 'ESTORE'	; 
			.TEXT 0x80+'G', 'OSUB'		; 
			.TEXT 0x80+'R', 'ETURN'		; 
			.TEXT 0x80+'R', 'EM'		; 
			.TEXT 0x80+'S', 'TOP'		; 
			.TEXT 0x80+'E', 'LSE'		; 
			.TEXT 0x80+'T', 'RON'		; 
			.TEXT 0x80+'T', 'ROFF'		; 
			.TEXT 0x80+'D', 'EFSTR'		; 
			.TEXT 0x80+'D', 'EFINT'		; 
			.TEXT 0x80+'D', 'EFSNG'		; 
			.TEXT 0x80+'D', 'EFDBL'		; 
			.TEXT 0x80+'L', 'INE'		; 
			.TEXT 0x80+'E', 'DIT'		; 
			.TEXT 0x80+'E', 'RROR'		; 
			.TEXT 0x80+'R', 'ESUME'		; 
			.TEXT 0x80+'O', 'UT'		; 
			.TEXT 0x80+'O', 'N'			; 
			.TEXT 0x80+'B', 'OOT'		; 
			.TEXT 0x80+'F', 'IELD'		; 
			.TEXT 0x80+'G', 'ET'		; 
			.TEXT 0x80+'P', 'UT'		; 
			.TEXT 0x80+'C', 'LOSE'		; 
			.TEXT 0x80+'C', 'MON'		; 
			.TEXT 0x80+'M', 'ERGE'		; 
			.TEXT 0x80+'N', 'AME'		; 
			.TEXT 0x80+'K', 'ILL'		; 
			.TEXT 0x80+'L', 'SET'		; 
			.TEXT 0x80+'R', 'SET'		; 
			.TEXT 0x80+'S', 'AVE'		; 
			.TEXT 0x80+'S', 'YSTEM'		; 
			.TEXT 0x80+'L', 'PRINT'		; 
			.TEXT 0x80+'D', 'EF'		; 
			.TEXT 0x80+'P', 'OKE'		; 
			.TEXT 0x80+'P', 'RINT'		; 
			.TEXT 0x80+'C', 'ONT'		; 
			.TEXT 0x80+'L', 'IST'		; 
			.TEXT 0x80+'L', 'LIST'		; 
			.TEXT 0x80+'D', 'ELETE'		; 
			.TEXT 0x80+'A', 'UTO'		; 
			.TEXT 0x80+'C', 'LEAR'		; 
			.TEXT 0x80+'C', 'LOAD'		; 
			.TEXT 0x80+'C', 'SAVE'		; 
			.TEXT 0x80+'N', 'EW'		; 
			.TEXT 0x80+'T', 'AB('		; 
			.TEXT 0x80+'T', 'O'			; 
			.TEXT 0x80+'F', 'N'			; 
			.TEXT 0x80+'U', 'SING'		; 
			.TEXT 0x80+'V', 'ARPTR'		; 
			.TEXT 0x80+'U', 'SR'		; 
			.TEXT 0x80+'E', 'RL'		; 
			.TEXT 0x80+'E', 'RR'		; 
			.TEXT 0x80+'S', 'TRING$'	; 
			.TEXT 0x80+'I', 'NSTR'		; 
			.TEXT 0x80+'P', 'OINT'		; 
			.TEXT 0x80+'T', 'IME$'		; 
			.TEXT 0x80+'M', 'EM'		; 
			.TEXT 0x80+'I', 'NKEY$'		; 
			.TEXT 0x80+'T', 'HEN'		; 
			.TEXT 0x80+'N', 'OT'		; 
			.TEXT 0x80+'S', 'TEP'		; 
			.TEXT 0x80+'+'				; 
			.TEXT 0x80+'-'				; 
			.TEXT 0x80+'*'				; 
			.TEXT 0x80+'/'				; 
			.TEXT 0x80+'^'				; 
			.TEXT 0x80+'A', 'ND'		; 
			.TEXT 0x80+'O', 'R'			; 
			.TEXT 0x80+'>'				; 
			.TEXT 0x80+'='				; 
			.TEXT 0x80+'<'				; 
			.TEXT 0x80+'S', 'GN'		; 
			.TEXT 0x80+'I', 'NT'		; 
			.TEXT 0x80+'A', 'BS'		; 
			.TEXT 0x80+'F', 'RE'		; 
			.TEXT 0x80+'I', 'NP'		; 
			.TEXT 0x80+'P', 'OS'		; 
			.TEXT 0x80+'S', 'QR'		; 
			.TEXT 0x80+'R', 'ND'		; 
			.TEXT 0x80+'L', 'OG'		; 
			.TEXT 0x80+'E', 'XP'		; 
			.TEXT 0x80+'C', 'OS'		; 
			.TEXT 0x80+'S', 'IN'		; 
			.TEXT 0x80+'T', 'AN'		; 
			.TEXT 0x80+'A', 'TN'		; 
			.TEXT 0x80+'P', 'EEK'		; 
			.TEXT 0x80+'C', 'VI'		; 
			.TEXT 0x80+'C', 'VS'		; 
			.TEXT 0x80+'C', 'VD'		; 
			.TEXT 0x80+'E', 'OF'		; 
			.TEXT 0x80+'L', 'OC'		; 
			.TEXT 0x80+'L', 'OF'		; 
			.TEXT 0x80+'M', 'KI$'		; 
			.TEXT 0x80+'M', 'KS$'		; 
			.TEXT 0x80+'M', 'KD$'		; 
			.TEXT 0x80+'C', 'INT'		; 
			.TEXT 0x80+'C', 'SNG'		; 
			.TEXT 0x80+'C', 'DBL'		; 
			.TEXT 0x80+'F', 'IX'		; 
			.TEXT 0x80+'L', 'EN'		; 
			.TEXT 0x80+'S', 'TR$'		; 
			.TEXT 0x80+'V', 'AL'		; 
			.TEXT 0x80+'A', 'SC'		; 
			.TEXT 0x80+'C', 'HR$'		; 
			.TEXT 0x80+'L', 'EFT$'		; 
			.TEXT 0x80+'R', 'IGHT$'		; 
			.TEXT 0x80+'M', 'ID$'		; 

			.BYTE 0xA7, 0x80			; '+0x80, 0x00+0x80
			
			; KWDTAB
			; Tabella puntatori a keyword
			;
KWDTAB		.DW END			
			.DW FOR			
			.DW RESET			
			.DW SET			
			.DW CLS			
			.DW SNERR2					; CMD		*
			.DW RANDOM
			.DW NEXT			
			.DW DATA			
			.DW INPUT			
			.DW DIM			
			.DW READ			
			.DW LET			
			.DW GOTO			
			.DW RUN			
			.DW IF			
			.DW RESTORE		
			.DW GOSUB			
			.DW RETURN		
			.DW REM			
			.DW STOP			
			.DW ELSE			
			.DW TRON			
			.DW TROFF			
			.DW DEFSTR		
			.DW DEFINT		
			.DW DEFSNG		
			.DW DEFDBL		
			.DW LINE			
			.DW EDIT			
			.DW ERROR			
			.DW RESUME		
			.DW OUT			
			.DW ON			
			.DW BOOT			
			.DW SNERR2					; FIELD	
			.DW SNERR2					; GET	
			.DW SNERR2					; PUT	
			.DW SNERR2					; CLOSE	
			.DW CMON 				
			.DW SNERR2					; MERGE	
			.DW SNERR2					; NAME	
			.DW SNERR2					; KILL	
			.DW SNERR2					; LSET	
			.DW SNERR2					; RSET	
			.DW SNERR2					; SAVE	
			.DW SYSTEM 		
			.DW LPRINT 		
			.DW DEF 			
			.DW POKE 			
			.DW PRINT 			
			.DW CONT 			
			.DW LIST 			
			.DW LLIST 			
			.DW DELETE 		
			.DW AUTO 			
			.DW CLEAR 			
			.DW CLOAD 			
			.DW CSAVE 			
			.DW NEW 			

			; Tabella PRITAB
			; Precedenze aritmetiche
			;
PRITAB		.BYTE 0x79, 0x79, 0x7C, 0x7C		 		; + - * / 
			.BYTE 0x7F, 0x50, 0x46						; ^ AND OR

			; Tabella TABCONV
			; Tabella puntatori a funzioni conversioni
			;
TABCONV		.DW CDBL	  			; DW 0x0ADB		CDBL
			.DW 0x0000  			; DW 0x0000		
			.DW CINT	  			; DW 0x0A7F		CINT
			.DW TSTSTR  			; DW 0x0AF4		TSTSTR
			.DW CSNG	  			; DW 0x0AB1		CSNG
			
			; TABOPER
			; Tabella puntatori ad operatori
			;
TABOPER		.DW 0x0C77				; DW 0x0C77
			.DW 0x0C70				; DW 0x0C70
			.DW 0x0DA1				; DW 0x0DA1
			.DW 0x0DE5				; DW 0x0DE5
			.DW 0x0A78				; DW 0x0A78
			.DW FPADD				; DW 0x0716		FPADD
			.DW FPSUB				; DW 0x0713		FPSUB
			.DW FPMULT				; DW 0x0847		FPMULT
			.DW DIVBCDE				; DW 0x08A2		DIVBCDE
			.DW CMPNUM				; DW 0x0A0C		CMPNUM
			.DW 0x0BD2				; DW 0x0BD2
			.DW 0x0BC7				; DW 0x0BC7
			.DW 0x0BF2				; DW 0x0BF2
			.DW 0x2490				; DW 0x2490
			.DW 0x0A39				; DW 0x0A39

			;
			; ERRMSGVEC
			; Tabella puntatori a messaggi d'errore
			;
ERRMSGVEC	.DW	ER00			
			.DW	ER02			
			.DW	ER04			
			.DW	ER06			
			.DW	ER08			
			.DW	ER0A			
			.DW	ER0C			
			.DW	ER0E			
			.DW	ER10			
			.DW	ER12			
			.DW	ER14			
			.DW	ER16			
			.DW	ER18			
			.DW	ER1A			
			.DW	ER1C			
			.DW	ER1E			
			.DW	ER20			
			.DW	ER22			
			.DW	ER24			
			.DW	ER26			
			.DW	ER28			
			.DW	ER2A			
			.DW ER02	; per ECOD2C	  

			;
			; Codice da copiare in RAM a partire da 0x4080
			;
			; Routine (0x4080) - DIVSUP
			;
DIVSUPROM	SUB 0x00				; (4080) Sottrae da A il valore 0x00		
			LD L,A					; (4082) Copia A in L
			LD A,H					; (4083) Copia H in A
			SBC A,0x00				; (4084) Sottrae da A il valore 0x00 e il CY
			LD H,A					; (4086) Copia A in H
			LD A,B					; (4087) Copia B in A
			SBC A,0x00				; (4088) Sottrae da A il valore 0x00 e il CY
			LD B,A					; (408A) Copia A in B
			LD A,0x00				; (408B) Azzera A
			RET     				; (408D) Ritorna
			;
			.BYTE 0x4A				; (408E) 
			.BYTE 0x1E, 0x40		; (408F) 
			.BYTE 0xE6, 0x4D		; (4091) 
			;
GENINPROM	IN A,(0x00)				; (4093) Input in A da porta xx, modificata alla locazione 0x4094
			RET						; (4095) Ritorna
			;
GENOUTROM	OUT (0x00),A			; (4096) Out di A su porta xx, modificata alla locazione 0x4097
			RET						; (4098) Ritorna
			;
			.BYTE 0x00				; (4099) LSTKEY
			.BYTE 0x00				; (409A) CURERR
			.BYTE 0x00				; (409B) CPOSPRN
			.BYTE 0x00 				; (409C) DEVOUT
			.BYTE 0x40				; (409D) PLEN
			.BYTE 0x30		 		; (409E) COMMAW
			.BYTE 0x00				; (409F) ?
			;
			.BYTE 0x4C, 0x43		; (40A0) 0x434C	Spazio per stringhe temporanee STLOOK
			.BYTE 0xFE, 0xFF		; (40A2) -2     Numero linea corrente (cold) LINEAT
			.BYTE 0xE9, 0x42		; (40A4) 0x42E9	Inizio testo programma+1	PROGST+1   

			.TEXT ' Error', 0x00	
MINLN		.TEXT ' in '
MNULST		.TEXT 0x00		
MREADY		.TEXT 'READY', 0x0D, 0x00
MSGBRK		.TEXT 'Break', 0x00		

			;
			; Routine 0x1936 - LKFORGOSUB
			;   Input: D tipo blocco cercato 0xFF=GOSUB
			;
LKFORGOSUB	LD HL,0x0004			; Carica in HL il valore 0x0004
			ADD HL,SP				; Somma SP ad Hç
			;
L193A		LD A,(HL)				; Carica in A da memoria puntata da (HL)
			INC HL					; Incrementa HL
			CP TKFOR				; Compara A con il valore 0x81 (Token FOR)
			RET NZ					; Se diverso, ritorna
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			INC HL					; Incrementa HL
			PUSH HL					; Salva HL nello stack
			LD L,C					; Copia C in L
			LD H,B					; Copia B in H
			LD A,D					; Copia D in A
			OR E					; Esegue OR di A con E
			EX DE,HL				; Scambia DE ed HL
			JR Z,L194D				; Se zero, passa a 0x194D
			EX DE,HL				; Scambia DE ed HL
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
L194D		LD BC,0x000E			; Carica in BC il valore 0x000E
			POP HL					; Recupera HL dallo stack
			RET Z					; Se zero, ritorna
			ADD HL,BC				; Somma BC ad HL
			JR L193A				; Passa a 0x193A (L193A LOKFOR), cerca blocchi FOR attivi

			;
			; Routine 0x1955 - MOVUP  Sposta area di memoria da sorgente a destinazione
			;   Input:	HL indirizzo sorgente iniziale
			;			DE indirizzo sorgente finale
			;			BC indirizzo destinazione iniziale
			;
MOVUP		CALL ENFMEM				; Chiama la 0x196C (L196C ENFMEM)
L1958		PUSH BC					; Salva BC nello stack
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			POP BC					; Recupera BC dallo stack
L195B		RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			LD (BC),A				; Salva A in memoria puntata da (BC)
			RET Z					; Se zero, ritorna
			DEC BC					; Decrementa BC
			DEC HL					; Decrementa HL
			JR L195B				; Passa a 0x195B, ciclo

			;
			; Routine 0x1963 - CHKSTK
			;  Input: C  livelli di stack richiesti (WORD richieste)
			;
CHKSTK		PUSH HL					; Salva HL nello stack
			LD HL,(ARREND)			; Carica in HL da memoria puntata da (0x40FD) ARREND
			LD B,0x00				; Azzera B
			ADD HL,BC				; Somma BC ad HL
			ADD HL,BC				; Somma BC ad HL
			.BYTE 0x3E				; Esegue LD A,0xE5, skip istruzione PUSH HL 
									;   continua con 0x196D 

			;
			; Routine 0x196C - ENFMEM  Controllo disponibilità memoria
			;
ENFMEM		PUSH HL					; Salva HL nello stack							; Save code string address
L196D		LD A,0xC6				; Carica in A il valore 0xC6 (-58 L)			; 58 Bytes minimum RAM
			SUB L					; Sottrae L da A
			LD L,A					; Copia A in L
			LD A,0xFF				; Carica in A il valore 0xFF (-58 H)			
			SBC A,H					; Sottrae H da A
			JR C,OMERR				; Se CY=1, passa a 0x197A (L197A OMERR)			; Not enough - ?OM Error
			LD H,A					; Copia A in H
			ADD HL,SP				; Somma SP ad HL								; Test if stack is overflowed
			POP HL					; Recupera HL dallo stack						; Restore code string address
			RET C					; Se CY=1, ritorna								; Return if enough mmory
									;   altrimenti passa a 0xL197A (L197A OMERR)

			; 
			; Routine 0x197A - OMERR  Out of Memory Error
			;
OMERR		LD E,ECOD0C				; Carica in E il valore 0x0C (codice Out of Memory Error)
			JR MSGERR				; Passa alla 0x19A2 (L19A2 MSGERR)

			; 
			; Routine 0x197E - ENDPRG  Fine programma
			;
ENDPRG		LD HL,(LINEAT)			; Carica in HL da memoria puntata da (0x40A2) LINEAT	; Get current line number
			LD A,H					; Copia H in A											; Is it direct break?
			AND L					; Esegue AND di A con L									
			INC A					; Incrementa A											; Line is -1 if direct break
			JR Z,L198E				; Se zero, passa a 0x198E								; Yes - No line number
			LD A,(RESACT)			; Carica in A da memoria puntata da (0x40F2) RESACT 			
			OR A					; Esegue OR di A										
			LD E,ECOD22				; Carica in E il valore 0x22 (codice No Resume Error)	
			JR NZ,MSGERR			; Se diverso da zero, passa a 0x19A2 (L19A2 MSGERR)		
L198E		JP L1DC1				; Passa a 0x1DC1 (L1DC1 ?)										

			;
			; Routine 0x1991 - DATSNR
			;
DATSNR 		LD HL,(DATLIN)			; Carica in HL da memoria puntata da (0x40DA) DATLIN	; Get line of current DATA item 
			LD (LINEAT),HL			; Salva HL in memoria puntata da (0x40A2) LINEAT		; Save as current line LINEAT
									;    continua con la 0x1997 (L1997 SNERR)

			;
			; Routine 0x1997 - SNERR Syntax Error
			;
SNERR		LD E,ECOD02				; Carica in E il valore 0x02 (SN Syntax)
			.BYTE 0x01				; Esegue LD BC,0x141E, skip LD E,ECOD14
									;   continua con 0x199C 
			
			;
			; Routine 0x199A - DZERR Division By Zero Error
			;
DZERR		LD E,ECOD14				; Carica in E il valore 0x14 (DZ Division By Zero)
L199C		.BYTE 0x01				; Esegue LD BC,0x001E, skip LD E,ECOD00
									;   continua con 0x199F 

			;
			; Routine 0x199D - NFERR Next Without For
			;
NFERR		LD E,ECOD00				; Carica in E il valore 0x00 (NF Next Without For)
L199F		.BYTE 0x01				; Esegue LD BC,0x241E, skip LD E,ECOD24
									;   continua con 0x19A2 (L19A2 MSGERR)
			
			;
			; Routine 0x19A0 - RWERR Resume Without Error
			;
RWERR		LD E,ECOD24				; Carica in E il valore 0x24 (RW Resume Without Error) 
									;  continua con la 0x19A2 (L19A2 MSGERR)

			;
			; Routine 0x19A2 - MSGERR  Visualizza messaggio di errore
			;   Input: E Codice di errore
			;
MSGERR		LD HL,(LINEAT)			; Carica in HL valore puntato da (0x40A2) LINEAT		; Get current line LINEAT
			LD (CURERL),HL			; Salva HL in memoria puntata da (0x40EA) CURERL
			LD (CUREDLN),HL			; Salva HL in memoria puntata da (0x40EC) CUREDLN
L19AB		LD BC,0x19B4			; Carica in BC il valore 0x19B4 (L19B4 ?)

			;
			; Routine 0x19AE - HDLNMI2  continua gestione NMI
			; 
HDLNMI2		LD HL,(SPTMP)			; Carica in HL valore puntato da (0x40E8) SPTMP
			JP HDLNMI3				; Passa a 0x1B9A (L1B9A HDLNMI3)

			;
			; Routine 0x19B4
			;
L19B4		POP BC					; Recupera BC dallo stack
			LD A,E					; Copia E in A 
			LD C,E					; Copia E in C
			LD (CURERR),A			; Salva A in memoria puntata da (0x409A) CURERR
			LD HL,(UNK03)			; Carica in HL da memoria puntata da (0x40E6) UNK03
			LD (UNK04),HL			; Salva HL in memoria puntata da (0x40EE) UNK04
			EX DE,HL				; Scambia DE ed HL
			LD HL,(CURERL)			; Carica in HL da memoria puntata da (0x40EA) CURERL
			LD A,H					; Copia H in A
			AND L					; Esegue AND di A ed L
			INC A					; Incrementa A
			JR Z,L19D0				; Se zero, passa a 0x19D0
			LD (0x40F5),HL			; Salva HL in memoria puntata da (0x40F5)
			EX DE,HL				; Scambia DE ed HL
			LD (0x40F7),HL			; Salva HL in memoria puntata da (0x40F7)
L19D0		LD HL,(ONERLN)			; Carica in HL da memoria puntata da (0x40F0) ONERLN
			LD A,H					; Copia H in A
			OR L					; Esegue OR di A ed L
			EX DE,HL				; Scambia DE ed HL
			LD HL,RESACT			; Carica in HL il valore 0x40F2 (puntatore a RESACT)
			JR Z,L19E3				; Se zero, passa a 0x19E3
			AND (HL)				; Esegue AND di A con memoria puntata da (HL)
			JR NZ,L19E3				; Se diverso da zero, passa a 0x19E3
			DEC (HL)				; Decrementa memoria puntata da (HL)
			EX DE,HL				; Scambia DE ed HL
			JP L1D36				; Passa a 0x1D36 (L1D36 ?)
L19E3		XOR A					; Azzera A
			LD (HL),A				; Salva A in memoria puntata da (HL)
			LD E,C					; Copia C in E
			CALL PRCRNZ				; Chiama la 0x20F9 (L20F9 PRCRNZ)
			LD HL,ERRMSGVEC			; Carica in HL il valore 0x18C9 (puntatore a ERRMSGVEC)
			LD D,A					; Copia A in D (codice errore)
			ADD HL,DE				; Somma DE ad HL (offset in tabella puntatori)
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD H,(HL)				; Carica in H da memoria puntata da (HL) (parte alta puntatore a messaggio d'errore)
			LD L,A					; Copia A in L (parte bassa puntatore a messaggio d'errore)
			;			
			; NOP da 0x19F2 a 0x1A00
			;
			DEFS 0x0F, 0x00
			;
			PUSH HL					; Salva HL nello stack
			LD HL,(CURERL)			; Carica in HL da memoria puntata da (0x40EA) CURERL
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			;
L1A06		CALL PRS				; Chiama la 0x28A7 (L28A7 PRS)
			POP HL					; Recupera HL dallo stack
			LD DE,0xFFFE			; Carica in DE il valore 0xFFFE (-2)
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JP Z,BASIC				; Se uguale, passa a 0x0674 (L0674 BASIC)
			LD A,H					; Copia H in A
			AND L					; Esegue AND di A con L
			INC A					; Incrementa A
			CALL NZ,VLINEIN			; Se diverso da zero, passa a 0x0FA7 (L0FA7 VLINEIN)
			.BYTE 0x3E				; Esegue LD A,0xC1, skip POP BC
									;  continua con 0x1A19 (L1A19 BASMAIN)
			;
			; 0x1A18 - BASMAIN2   Elimina indirizzo di ritorno dallo stack e passa al main BASIC entry point
			;
BASMAIN2	POP BC					; Recupera BC dallo stack
									;  contiuna con 0x1A19 (L1A19 BASMAIN)

			;
			; 0x1A19 - BASMAIN  Main BASIC entry point
			;
BASMAIN		CALL RESPRN				; Chiama la 0x038B (L038B RESPRN), reset stato stampante
			NOP     				;
			NOP     				;
			NOP     				;
			CALL VSNDTAPE18			; Chiama la 0x01F8 (L01F8 VSNDTAPE18), reset tape
			CALL PRCRNZ				; Chiama la 0x20F9 (L20F9 PRCRNZ), va a capo 
			LD HL,MREADY			; Carica in HL il valore 0x1929 (puntatore a 'READY')
			CALL PRS				; Chiama la 0x28A7 (L28A7 PRS), visualizza 'READY'
			LD A,(CURERR)			; Carica in A il valore puntato da (0x409A) CURERR
			SUB ECOD02				; Sottrae da A il valore 0x02 (ECOD02. codice Syntax Error)
			CALL Z,ZERR				; Se uguale a zero, chiama la 0x2E53 (L2E53 ZERR)
									;   altrimenti continua con la 0x1A33 (L1A33 GETCMD)

			;
			; Routine 0x1A33 - GETCMD  Esecuzione prossimo comando
			;
GETCMD		LD HL,0xFFFF			; Carica in HL il valore 0xFFFF (-1)
			LD (LINEAT),HL			; Salva HL in memoria puntata da (0x40A2) LINEAT, linea in esecuzione
									;
			LD A,(AUTOACT)			; Carica in A il valore puntato da (0x40E1) AUTOACT
			OR A					; Esegue OR di A
			JR Z,L1A76				; Se uguale a zero, passa a 0x1A76 (L1A76 PROMPT)
			;
			LD HL,(AUTONXTL)		; Carica in HL il valore puntato da (0x40E2) AUTONXTL
			PUSH HL					; Salva HL nello stack
			CALL PRNTHL				; Chiama la 0x0FAF (L0FAF PRNTHL)
			POP DE					; Recupera DE dallo stack
			PUSH DE					; Salva DE nello stack
			CALL SRCHLN				; Chiama la 0x1B2C (L1B2C SRCHLN)
			LD A,'*'				; Carica in A il valore 0x2A (carattere '*')
			JR C,L1A51				; Se CY=1, passa a 0x1A51
			LD A,' '				; Carica in A il valore 0x20 (carattere ' ')
L1A51		CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
									;
			CALL GETLINE			; Chiama la 0x0361 (L0361 GETLINE)
			POP DE					; Recupera DE dallo stack
			JR NC,L1A60				; Se CY=0, passa a 0x1A60
									;
L1A5A		XOR A					; Azzera A
			LD (AUTOACT),A			; Azzera memoria puntata da (0x40E1) AUTOACT
			JR BASMAIN				; Passa a 0x1A19 (L1A19 BASMAIN)
									;
L1A60		LD HL,(AUTOSTEP)		; Carica in HL valore puntato da (0x40E4) AUTOSTEP
			ADD HL,DE				; Somma DE ad HL
			JR C,L1A5A				; Se CY=1, passa a 0x1A5A
			PUSH DE					; Salva DE nello stack
			LD DE,0x0FFF9			; Carica in DE il valore 0xFFF9 (-7)
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			POP DE					; Recupera DE dallo stack
			JR NC,L1A5A				; Se CY=0, passa a 0x1A5A
			LD (AUTONXTL),HL		; Salva HL in memoria puntata da (0x40E2) AUTONXTL
			OR 0xFF					; Esegue OR di A con il valore 0xFF
			JP L2FEB				; Passa a 0x2FEB (L2FEB ?)
			
			;
			; Routine 0x1A76 - PROMPT 
			;
L1A76		LD A,'>'				; Carica in A il valore 0x3E (carattere '>')
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA), visualizza >
									;
			CALL GETLINE			; Chiama la 0x0361 (L0361 GETLINE)
			JP C,GETCMD				; Se CY=1, passa a 0x1A33 (L1A33 GETCMD)
									;
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			INC A					; Incrementa A
			DEC A					; Decrementa A
			JP Z,GETCMD				; Se zero, passa a 0x1A33 (L1A33 GETCMD)
			PUSH AF					; Salva AF nello stack
			CALL ATOH				; Chiama la 0x1E5A (L1E5A ATOH)
L1A8B		DEC HL					; Decrementa HL
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CP ' '					; Compara A con il valore 0x20 (carattere ' ')
			JR Z,L1A8B				; Se zero, passa a 0x1A8B (L1A8B), ciclo
									;
			INC HL					; Incrementa HL
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CP ' '					; Compara A con il valore 0x20 (carattere ' ')
			CALL Z,INCHL			; Se zero, chiama alla 0x09C9 (L09C9 INCHL)
L1A98		PUSH DE					; Salva DE nello stack
			CALL CRUNCH				; Chiama la 0x1BC0 (L1BC0 CRUNCH)
			POP DE					; Recupera DE dallo stack
			POP AF					; Recupera AF dallo stack
			LD (UNK03),HL			; Salva HL in memoria puntata da (0x40E6) UNK03
			NOP						;
			NOP						;
			NOP						;
			JP NC,EXCUTE			; Se CY=0, passa a 0x1D5A (L1D5A EXCUTE)
			PUSH DE					; Salva DE nello stack
			PUSH BC					; Salva BC nello stack
			XOR A					; Azzera A
			LD (LSTBIN),A			; Azzera memoria puntata da (0x40DD) LSTBIN
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			OR A					; Esegue OR di A
			PUSH AF					; Salva AF nello stack
			EX DE,HL				; Scambia DE ed HL
			LD (CUREDLN),HL			; Salva HL in memoria puntata da (0x40EC) CUREDLN
			EX DE,HL				; Scambia DE ed HL
			CALL SRCHLN				; Chiama la 0x1B2C (L1B2C SRCHLN)
			PUSH BC					; Salva BC nello stack
			CALL C,L2BE4			; Se CY=1, chiama la 0x2BE4 (L2BE4 ?)
			POP DE					; Recupera DE dallo stack
			POP AF					; Recupera AF dallo stack
			PUSH DE					; Salva DE nello stack
			JR Z,PREPEXEC			; Se zero, passa a 0x1AE8 (L1AE8 PREPEXEC)
			POP DE					; Recupera DE dallo stack
			LD HL,(PRGEND)			; Carica in HL da memoria puntata da (0x40F9)
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			POP BC					; Recupera BC dallo stack
			ADD HL,BC				; Somma BC ad HL
			PUSH HL					; Salva HL nello stack
			CALL MOVUP				; Chiama la 0x1955 (L1955 MOVUP)
			POP HL					; Recupera HL dallo stack
			LD (PRGEND),HL			; Salva HL in memoria puntata da (0x40F9)
			EX DE,HL				; Scambia DE ed HL
			LD (HL),H				; Salva H in memoria puntata da (HL)
			POP DE					; Recupera DE dallo stack
			PUSH HL					; Salva HL nello stack
			INC HL					; Incrementa HL
			INC HL					; Incrementa HL
			LD (HL),E				; Salva E in memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD (HL),D				; Salva D in memoria puntata da (HL)
			INC HL					; Incrementa HL
			EX DE,HL				; Scambia DE ed HL
			LD HL,(PBUFFER)			; Carica in HL da memoria puntata da (0x40A7) PBUFFER
			EX DE,HL				; Scambia DE ed HL
			DEC DE					; Decrementa DE
			DEC DE					; Decrementa DE
			;
L1AE1		LD A,(DE)				; Carica in A da memoria puntata da (DE)
			LD (HL),A				; Salva A in memoria puntata da (HL)
			INC HL					; Incrementa HL
			INC DE					; Incrementa DE
			OR A					; Esegue OR di A
			JR NZ,L1AE1				; Se diverso da zero, passa a 0x1AE1, ciclo
									;   continua con la 0x1AE8 (L1AE8 PREPEXEC)
			
			;
			; Routine 0x1AE8 - PREPEXEC  Prepara ad eseguire il codice
			;
PREPEXEC	POP DE					; Recupera DE dallo stack
			CALL TXTRELNK			; Chiama la 0x1AFC (L1AFC TXTRELNK), relink del codice a partire da DE
			NOP						;
			NOP						;
			NOP						;
			CALL RUNFST				; Chiama la 0x1B5D (L1B5D RUNFST), reset puntatori Basic per esecuzione
			NOP						;
			NOP						;
			NOP						;
			JP GETCMD				; Passa a 0x1A33 (L1A33 GETCMD), esegue prossimo comando

			;
			; Routine 0x1AF8 (non utilizzata?)
			;
			LD HL,(BASTXT)			; Carica in HL da memoria puntata da (0x40A4) BASTXT	
			EX DE,HL				; Scambia DE ed HL										
									;   continua con la 0x1AFC (L1AFC TXTRELNK)

			;
			; Routine 0x1AFC - TXTRELNK  Ricostruisce linked list del codice del programma
			;   Input: DE indirizzo iniziale codice da esaminare
			;
TXTRELNK	LD H,D					; Copia D in H											; Address to HL
			LD L,E					; Copia E in L											;
			LD A,(HL)				; Carica in A da memoria puntata da (HL)				; Get LSB of pointer
			INC HL					; Incrementa HL											; To MSB of pointer
			OR (HL)					; Esegue OR di A con memoria puntata da (HL)			; Compare with MSB pointer
			RET Z					; Se zero, ritorna										; Get command line if end
			INC HL					; Incrementa HL											; To LSB of line number
			INC HL					; Incrementa HL											; Skip line number
			INC HL					; Incrementa HL											; Point to first byte in line
			XOR A					; Azzera A												; Looking for 00 byte
L1B06		CP (HL)					; Compara A con memoria puntata da (HL)					; Found end of line?
			INC HL					; Incrementa HL											; Move to next byte
			JR NZ,L1B06				; Se diverso da zero, passa a 0x1B06,ciclo				; No - Keep looking
			EX DE,HL				; Scambia DE ed HL										; Next line address to HL
			LD (HL),E				; Salva E in memoria puntata da (HL)					; Save LSB of pointer
			INC HL					; Incrementa HL											
			LD (HL),D				; Salva D in memoria puntata da (HL)					; Save MSB of pointer
			JR TXTRELNK				; Passa a 0x1AFC (L1AFC TXTRELNK)						; Do next line
																										
			;
			; Routine 0x1B10																			
			;
L1B10		LD DE,0x0000			; Azzera DE																
			PUSH DE					; Salva DE nello stack
			JR Z,L1B1F				; Se zero, passa a 0x1B1F
			POP DE					; Recupera DE dallo stack
			CALL GETVALDE			; Chiama la 0x1E4F (0x1E4F GETVALDE)
			PUSH DE					; Salva DE nello stack
			JR Z,L1B28				; Se zero, passa a 0x1B28 (L1B28)
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE TKMINUS			; (Token -)
L1B1F		LD DE,0xFFFA			; Carica in DE il valore 0xFFFA
			CALL NZ,GETVALDE		; Se diverso da zero, chiama la 0x1E4F (L1E4F GETVALDE)
			JP NZ,SNERR				; Se diverso da zero, passa alla 0x1997 (L1997 SNERR)
L1B28		EX DE,HL				; Scambia DE ed HL
			POP DE					; Recupera DE dallo stack
									;   continua con la 0x1B2A (L1B2A SRCHLN2)

			;
			; Routine 0x1B2A - SRCHLN2
			;  Input:  DE numero linea ricercata
			;  Output: BC indirizzo linea ricercata
			;
L1B2A		EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			PUSH HL					; Salva HL nello stack
									;   continua con la 0x1B2C (L1B2C SRCHLN)

			;
			; Routine 0x1B2C - SRCHLN
			;  Input:  DE numero linea ricercata
			;  Output: BC indirizzo linea ricercata
			;
SRCHLN 		LD HL,(BASTXT)			; Carica in HL da memoria puntata da (0x40A4) BASTXT; Start of program text
			; 
SRCHLP		LD B,H					; Copia H in B                                      ; BC = Address to look at
			LD C,L					; Copia L in C                                      
			LD A,(HL)				; Carica in A da memoria puntata da (HL)			; Get address of next line
			INC HL					; Incrementa HL                                                                   
			OR (HL)					; Esegue OR A con memoria puntata da (HL)			; End of program found?
			DEC HL					; Decrementa HL	 
			RET Z					; Se zero, ritorna									; Yes - Line not found
			INC HL					; Incrementa HL
			INC HL					; Incrementa HL
			LD A,(HL)				; Carica in A memoria puntata da (HL)				; Get LSB of line number
			INC HL					; Incrementa HL                                     
			LD H,(HL)				; Carica in H memoria puntata da (HL)				; Get MSB of line number
			LD L,A					; Copia A in L	      
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)				; Compare with line in DE
			LD H,B					; Copia B in H										; HL = Start of this line
			LD L,C					; Copia C in L                                                    
			LD A,(HL)				; Carica in A da memoria puntata da (HL)			; Get LSB of next line address
			INC HL					; Incrementa HL                                                    
			LD H,(HL)				; Carica in A da memoria puntata da (HL)			; Get MSB of next line address
			LD L,A					; Copia A in L										; Next line to HL
			CCF						; Inverte CY                                                                      
			RET Z					; Se zero, ritorna									; Lines found - Exit
			CCF						; Inverte CY                                                    
			RET NC					; Se CY=0, ritorna									; Line not found,at line after
			JR SRCHLP				; Passa a 0x1B2F (L1B2F SRCHLP), loop				; Keep looking SRCHLP

			;
			; Routine 0x1B49 - NEW
			;
NEW 		RET NZ					; Se diverso da zero, ritorna						; Return if any more on line
			CALL CLS				; Chiama la 0x01C9 (L01C9 CLS)
									;   continua con la 0x1B4D (L1B4D CLRPTR)

			;
			; Routine 0x1B4D - CLRPTR  Reset puntatori area codice
			;
CLRPTR		LD HL,(BASTXT)			; Carica in HL memoria puntata da (0x40A4) BASTXT	; Point to start of program BASTXT
			CALL TROFF				; Chiama la 0x1DF8 (L1DF8 TROFF)					; ? Set program area to empty
			LD (AUTOACT),A			; Azzera memoria puntata da (0x40E1) AUTOACT
			LD (HL),A    			; Azzera memoria puntata da (HL)					; Save LSB = 00
			INC HL					; Incrementa HL										           	
			LD (HL),A				; Azzera memoria puntata da (HL)					; Save MSB = 00
			INC HL					; Incrementa HL										           	
			LD (PRGEND),HL			; Salva A in memoria puntata da (0x40F9) PRGEND		; Set program end PRGEND
									;  continua con 0x1B5D (L1B5D RUNFST)

			; 
			; Routine 0x1B5D - RUNFST  Reset esecuzione codice 
			;
RUNFST		LD HL,(BASTXT)			; Carica in HL memoria puntata da (0x40A4) BASTXT
			DEC HL					; Decrementa HL
									;   continua con 0x1B61 (L1B61 INTVAR)

			;
			; Routine 0x1B61 - INTVAR Inizializza tipo variabili
			;
L1B61		LD (PCODE2RUN),HL		; Salva HL in memoria puntata da (0x40DF) PCODE2RUN, punta a testo BASIC da eseguire
									;
									; Definisce tutte le variabili come SNG (DEFSNG A-Z)
			LD B,0x1A				; Carica in B il valore 0x1A (26 variabili)							
			LD HL,DEFTVAR			; Carica in HL il valore 0x4101	(puntatore tabella tipo variabili DEFTVAR)	 
L1B69		LD (HL),0x04			; Salva il valore 0x04 in memoria puntata da (HL) (default tipo single)		
			INC HL					; Incrementa HL											
			DJNZ L1B69				; Ripete a 0x1B69 fino a che B si azzera
			;				
			XOR A					; Azzera A																		
			LD (RESACT),A			; Azzera memoria puntata da (0x40F2) RESACT, nessun RESUME attivo
			LD L,A					; Copia A in L
			LD H,A					; Copia A in H, azzera HL
			LD (ONERLN),HL			; Azzera memoria puntata da (0x40F0) ONERLN
			LD (0x40F7),HL			; Azzera memoria puntata da (0x40F7)
			LD HL,(EOFRAM)			; Carica in HL memoria puntata da (HL) EOFRAM
			LD (STRBOT),HL			; Salva HL in memoria puntata da (0x40D6) STRBOT, reset spazio stringhe
			CALL RESTORE			; Chiama la 0x1D91 (L1D91 RESTORE), reset puntatore DATA
			LD HL,(PRGEND)			; Carica in HL memoria puntata da (0x40F9) PRGEND
			LD (VAREND),HL			; Salva HL in memoria puntata da (0x40FB) VAREND, reset area variabili Basic
			LD (ARREND),HL			; Salva HL in memoria puntata da (0x40FD) ARREND, reset area array Basic
			;
			NOP						;	continua con 0x1B8F (L1B8F CLREG)
			NOP						;
			NOP						;

			; 																							
			; Routine 0x1B8F - CLREG - Clear registers and stack
			;
CLREG		POP BC					; Recupera BC dallo stack, indirizzo di rientro
			LD HL,(STRSPC)			; Carica HL da (0x40A0) STRSPC					; Get bottom of string space in use STRSPC
			DEC HL					; Decrementa HL										
			DEC HL					; Decrementa HL										
			LD (SPTMP),HL			; Salva HL in (0x40E8) SPTMP
			INC HL					; Incrementa HL							
			INC HL					; Incrementa HL			;				
									;  continua con la 0x1B9A (L1B9A HDLNMI3)

			;
			; Routine 0x1B9A - HDLNMI3  continuazione gestione NMI
			;   Input: HL
			;
HDLNMI3		LD SP,HL				; Imposta SP con HL
			LD HL,TSAREA			; Carica il valore 0x40B5 in HL	(puntatore a TSAREA)		
			LD (TMSTPT),HL			; Salva HL in (0x40B3) TMSTPT
			CALL RESPRN				; Chiama la 0x038B (L038B RESPRN)
			CALL SETDEFVID			; Chiama la 0x2169 (L2169 SETDEFVID)
			XOR A					; Azzera A										; A = 00
			LD H,A					; Azzera H										; HL = 0000
			LD L,A					; Azzera L								
			LD (FORFLG),A			; Azzera memoria puntata da (0x40DC) FORFLG		; Clear FOR flag FORFLG
			PUSH HL					; Salva HL nello stack							; HL = 0000	
			PUSH BC					; Salva BC nello stack							; Put back return	
			LD HL,(PCODE2RUN)		; Carica HL da (0x40DF) PCODE2RUN				; Get address of code to RUN 
			RET     				; Ritorna										; Return to execution driver	
																								
			; 																					
			; Routine 0x1BB3 - VISPPIN  Visualizza '? ' e input stringa da tastiera - PROMPT
			;
VISPPIN		LD A,'?'				; Carica in A il valore 0x3F (carattere '?')
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
			LD A,' '				; Carica in A il valore 0x20 (carattere ' ')
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
			JP GETLINE				; Passa a 0x0361 (L0361 GETLINE)

			;
			; Routine 0x1BC0 - CRUNCH Tokenizza testo codice
			;
CRUNCH 		XOR A					; Azzera A
			LD (DATFLG),A			; Azzera memoria puntata da (0x40B0) DATFLG					; Reset literal flag DATFLG
			LD C,A					; Azzera C
			EX DE,HL				; Scambia DE ed HL
			LD HL,(PBUFFER)			; Carica in HL da memoria puntata da (0x40A7) PBUFFER
			DEC HL					; Decrementa HL
			DEC HL					; Decrementa HL
			EX DE,HL				; Scambia DE ed HL											; Start of input buffer
L1BCC		LD A,(HL)				; Carica in A memoria puntata da (HL)						; Get byte
			CP ' '					; Compara A con il valore 0x20 (carattere ' ')				; Is it a space?
			JP Z,L1C5B				; Se uguale, passa a 0x1C5B									; Yes - Copy direct
			LD B,A					; Copia A in B												; Save character
			CP '"'					; Compara A con il valore 0x22 (carattere '"')				; Is it a quote?
			JP Z,L1C77				; Se uguale, passa a 0x1C77									; Yes - Copy literal string
			OR A					; Esegue OR di A											; Is it end of buffer?
			JP Z,ENDBUF				; Se zero, passa a 0x1C7D (L1C7D ENDBUF)					; Yes - End buffer
			LD A,(DATFLG)			; Carica in A memoria puntata da (0x40B0) DATFLG			; Get data type (01 Literal)
			OR A					; Esegue OR di A											; Literal?
			LD A,(HL)				; Carica in A da memoria puntata da (HL)					; Get byte to copy
			JP NZ,L1C5B				; Se diverso, passa a 0x1C5B								; Literal - Copy direct
			CP '?'					; Compara con il valore 0x3F (carattere '?')				; Is it '?' short for PRINT
			LD A,TKPRINT			; Carica in A il valore 0xB2 (token PRINT)					; "PRINT" token
			JP Z,L1C5B				; Se uguale, passa a 0x1C5B									; Yes - replace it
			LD A,(HL)				; Carica in A da memoria puntata da (HL)					; Get byte again
			CP '0'					; Compara con il valore 0x30 (carattere '0')				; Is it less than '0'
			JR C,L1BF5				; Se CY=1, passa a 0x1BF5									; Yes - Look for reserved words
			CP '<'					; Compara con il valore 0x3C (carattere '<')				; Is it "0123456789:;" ?
			JP C,L1C5B				; Se CY=1, passa a 0x1C5B									; Yes - copy it direct
L1BF5		PUSH DE					; Salva DE nello stack										; Look for reserved words
			LD DE,KWORDS-1			; Carica in DE il valore 0x164F (Tabella KWORDS-1)			; Point to table-1
			PUSH BC					; Salva BC nello stack										; Save count
			LD BC,L1C3D				; Carica in BC il valore 0x1C3D (puntatore a L1C3D)			; Where to return to
			PUSH BC					; Salva BC nello stack										; Save return address
			LD B,FIRSTTK-1			; Carica in B il valore 0x7F (Primo token-1)				; First token value -1
			LD A,(HL)				; Carica in A da memoria puntata da (HL)					; Get byte
			CP 'a'					; Compara A con il valore 0x61 (carattere 'a')				; Less than 'a' ?
			JR C,L1C0C				; Se CY=, passa a 1C0C										; Yes - search for words
			CP 'z'+1				; Compara A con il valore 0x7B (carattere '{')				; Greater than 'z' ?
			JR NC,L1C0C				; Se CY=0, passa a 0x1C0C									; Yes - search for words
			AND 0x5F				; Esegue AND di A con il valore 0x5F						; Force upper case
			LD (HL),A				; Salva A in memoria puntata da (HL)						; Replace byte
L1C0C		LD C,(HL)				; Carica in A da memoria puntata da (HL)					; Search for a word
			EX DE,HL				; Scambia DE ed HL
									; Ricerca inizio riga in tabella parole chiave
NXTKW		INC HL					; Incrementa HL												; Get next reserved word
			OR (HL)					; Esegue OR di A con memoria puntata da (HL)				; Start of word?
			JP P,NXTKW				; Se positivo, passa a 0x1C0E (L1C0E NXTKW), non è ad inizio riga			; No - move on
									; 
			INC B					; Incrementa B, prossimo token								; Increment token value
			LD A,(HL)				; Carica in A da memoria puntata da (HL)					; Get byte from table
			AND 0x7F				; Esegue AND di A con 0x7F									; Strip bit 7
			RET Z					; Se zero, ritorna											; Return if end of list
			CP C					; Compara A con C											; Same character as in buffer?
			JR NZ,NXTKW				; Se diverso, passa a 0x1C0E (L1C0E NXTKW)					; No - get next word
									;
			EX DE,HL				; Scambia DE ed HL
			PUSH HL					; Salva HL nello stack										; Save start of word
L1C1D		INC DE					; Incremeta DE												; Look through rest of word
			LD A,(DE)				; Carica in A da memoria puntata da (DE)					; Get byte from table
			OR A					; Esegue OR di A											; End of word ?
			JP M,L1C39				; Se negativo, passa a 0x1C39								; Yes - Match found
			LD C,A					; Copia A in C												; Save it
			LD A,B					; Copia B in A												; Get token value
			CP TKGOTO				; Compara A con 0x8D (token GOTO)							; Is it "GOTO" token 
			JR NZ,L1C2B				; Se diverso, passa a 0x1C2B								; No - Don't allow spaces
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)	; Get next character
			DEC HL					; Decrementa HL												; Cancel increment from GETCHR
L1C2B		INC HL					; Incrementa HL												; Next byte
			LD A,(HL)				; Carica in A da memoria puntata da (HL)					; Get byte
			CP 'a'					; Compara A con il valore 0x61 (carattere 'a')				; Less than 'a' ?
			JR C,L1C33				; Se CY=1, passa a 0x1C33									; Yes - don't change
			AND 0x5F				; Esegue AND di A con il valore 0x5F						; Make upper case
L1C33		CP C					; Compara A con C											; Same as in buffer ?
			JR Z,L1C1D				; Se uguale, passa a 0x1C1D									; Yes - keep testing
			POP HL					; Recupera HL dallo stack									; Get back start of word
			JR L1C0C				; Passa a 0x1C0C											; Look at next word
			;
L1C39		LD C,B					; Copia B in C												; Word found - Save token value
			POP AF					; Recupera AF dallo stack									; Throw away return
			EX DE,HL				; Scambia DE ed HL
			RET     				; Ritorna (a 0x1C3D)										; Return to "RETNAD"
			;
L1C3D		EX DE,HL				; Scambia DE ed HL											; Get address in string
			LD A,C					; Copia C in A												; Get token value
			POP BC					; Recupera BC dallo stack									; Restore buffer length
			POP DE					; Recupera DE dallo stack									; Get destination address
			EX DE,HL				; Scambia DE ed HL		
			CP TKELSE				; Compara A con il valore 0x95 (token ELSE)					; No - Leave flag
			LD (HL),0x3A			; Salva il valore 0x3A in memoria puntata da (HL)			; Copy rest of buffer
			JR NZ,L1C4A				; Se diverso, passa a 0x1C4A								; Get byte
			INC C					; Incrementa C												; End of line ?			
			INC HL					; Incrementa HL
L1C4A		CP 0xFB					; Compara A con 0xFB											
			JR NZ,L1C5A				; Se diverso, passa a 0x1C5A									
			LD (HL),0x3A			; Salva il valore 0x3A (carattere ':') in memoria puntata da (HL)
			INC HL					; Incrementa HL																	
			LD B,TKREM				; Carica in B, il valore 0x93 (Token REM)
			LD (HL),B				; Salva B in memoria puntata da (HL)
			INC HL					; Incrementa HL
			EX DE,HL				; Scambia DE ed HL																
			INC C					; Incrementa C																
			INC C					; Incrementa C																
			JR L1C77				; Passa a 0x1C77
			;																	
L1C5A		EX DE,HL				; Scambia DE ed HL														
L1C5B		INC HL					; Incrementa HL												; Next source in buffer
			LD (DE),A				; Salva A in memoria puntata da (DE)						; Put byte in buffer	
			INC DE					; Incrementa DE												; Move up buffer	
			INC C					; Incrementa C												; Increment length of buffer	
			SUB ':'					; Sottrae da A il valore 0x3A (carattere ':')				; End of statement?	
			JR Z,L1C67				; Se zero, passa a 0x1C67									; Jump if multi-statement line	
			CP TKDATA-':'			; Compara A con il valore 0x4E (Token DATA-0x3A)			; Is it DATA statement ? (Token DATA-0x3A)
			JR NZ,L1C6A				; Se diverso, passa a 0x1C6A								; No - see if REM	
L1C67		LD (DATFLG),A			; Salva A in memoria puntata da (0x40B0) DATFLG				; Set literal flag	
L1C6A		SUB 0x59				; Sottrae da A il valore 0x59								; Is it REM?
			JP NZ,L1BCC				; Se diverso da zero, passa a 0x1BCC						; Yes - Terminate buffer
			LD B,A					; Copia A in B												; End of statement ?
									;
L1C70		LD A,(HL)				; Carica in A memoria puntata da (HL)						
			OR A					; Esegue OR di A											
			JR Z,ENDBUF				; Se zero, passa a 0x1C7D (L1C7D ENDBUF)					
			CP B					; Compara A con B											
			JR Z,L1C5B				; Se uguale, passa a 0x1C5B									; Yes - Get next one
L1C77		INC HL					; Incrementa HL												; Move up source string
			LD (DE),A				; Salva A in memoria puntata da (DE)						; Save in destination
			INC C					; Incrementa C												; Increment length
			INC DE					; Incrementa DE												; Move up destination	
			JR L1C70				; Passa a 0x1C70, ciclo										; Repeat

			;
			; Routine 0x1C7D - ENDBUF
			;	Input: A=0
			;
ENDBUF		LD HL,0x0005			; Carica in HL il valore 0x0005
			LD B,H					; Copia H in B
			ADD HL,BC				; Somma BC ad HL
			LD B,H					; Copia H in B
			LD C,L					; Copia L in C
			LD HL,(PBUFFER)			; Carica in HL da memoria puntata da (0x40A7) PBUFFER
			DEC HL					; Decrementa HL
			DEC HL					; Decrementa HL
			DEC HL					; Decrementa HL
			LD (DE),A				; Azzera memoria puntata da (DE)
			INC DE					; Incrementa DE
			LD (DE),A				; Azzera memoria puntata da (DE)
			INC DE					; Incrementa DE
			LD (DE),A				; Azzera memoria puntata da (DE)
			RET						; Return

			;
			; Routine 0x1C90 - CPDEHL Compara DE con HL (da RST 0x18)
			;
CPDEHL		LD A,H					; Copia H in A
			SUB D					; Sottrae D da A
			RET NZ					; Se diverso da zero, ritorna
			LD A,L					; Copia L in A
			SUB E					; Sottrae E da A
			RET     				; Ritorna

			;
			; Routine 0x1C96 - CKCHAR  Controlla carattere puntato da (HL)  (da RST 0x08)
			;   Input:  HL puntatore a carattere (comparato con carattere seguente la RST nel codice)
			;   Output: A prossimo carattere se non c'è errore di sintassi
			;
CKCHAR 		LD A,(HL)				; Carica in A memoria puntata da (HL)
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			CP (HL)					; Compara A con memoria puntata da (HL)
			INC HL					; Incrementa HL
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			JP Z,GETCH				; Se zero, passa alla 0x1D78 (L1D78 GETCH)
			JP SNERR				; Passa a 0x1997 (L1997 SNERR)

			;
			; Routine 0x1CA1 - FOR			
			;
FOR			LD A,FLAGFOR			; Carica in A il valore 0x64 (FLAGFOR)				; Flag "FOR" assignment
			LD (FORFLG),A			; Salva A in memoria puntata da (0x40DC) FORFLG		; Save "FOR" flag FORFLG
			CALL LET				; Chiama la 0x1F21 (L1F21 LET), assegna valore variabile indice
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)			; Drop RETurn address Save code string address
			CALL LKFORGOSUB			; Chiama la 0x1936 (L1936 LKFORGOSUB), cerca blocchi FOR attivi
			POP DE					; Recupera DE dallo stack							; Get code string address
			JR NZ,L1CB5				; Se diverso da zero, passa a 0x1CB5, nessun blocco FOR trovato
			ADD HL,BC				; Somma BC ad HL									; Move into "FOR" block
			LD SP,HL				; Copia HL in SP									; Remove all nested loops
			LD (SPTMP),HL			; Salva HL in memoria puntata da (0x40E8) SPTMP
L1CB5		EX DE,HL				; Scambia DE ed HL									; Code string address to HL
			LD C,0x08				; Carica in C il valore 0x08, test per 8 livelli di stack	; Stack levels
			CALL CHKSTK				; Chiama la 0x1963 (L1963 CHKSTK)					; Check for 8 levels of stack
			PUSH HL					; Salva HL nello stack								; Save code string address
			CALL DATA				; Chiama la 0x1F05 (L1F05 DATA)
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			PUSH HL					; Salva HL nello stack													
			LD HL,(LINEAT)			; Carica in HL memoria puntata da (0x40A2) LINEAT										
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE TKTO				; (Token TO)
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)				; Get "TO" expression value
			JP Z,TMERR				; Se zero, passa a 0x0AF6 (L0AF6 TMERR)
			JP NC,TMERR				; Se CY=0, passa a 0x0AF6 (L0AF6 TMERR)
			PUSH AF					; Salva AF nello stack
			CALL EVAL				; Chiama la 0x2337 (L2337 EVAL), calcolo valore finale dopo la TO
			POP AF					; Recupera AF dallo stack
			PUSH HL					; Salva HL nello stack
			JP P,L1CEC				; Se positivo, passa a 0x1CEC
									;
									; Indice della FOR intero
			CALL CINT				; Chiama la 0x0A7F (L0A7F CINT), converte valore in intero
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			LD DE,0x0001			; Carica in DE il valore 0x0001, STEP di default	; DE 1 (default Step) per indice intero
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CP TKSTEP				; Compara A con il valore 0xCC (Token STEP), controlla presenza STEP
			CALL Z,GETNSINT			; Se uguale, chiama la 0x2B01 (L2B01 GETNSINT), accetta un intero
			PUSH DE					; Salva DE nello stack
			PUSH HL					; Salva HL nello stack
			EX DE,HL				; Scambia DE ed HL
			CALL L099E				; Chiama la 0x099E (L099E ?)
			JR L1D0E				; Passa a 0x1D0E
									;
									; Indice della FOR singola precisione
L1CEC		CALL CSNG				; Chiama la 0x0AB1 (L0AB1 CSNG), converte valore in intero
			CALL FPR2BCDE			; Chiama la 0x09BF (L09BF FPR2BCDE)
			POP HL					; Recupera HL dallo stack
			PUSH BC					; Salva BC nello stack
			PUSH DE					; Salva DE nello stack
			LD BC,0x8100			; Carica in BC il valore 0x8100, STEP di default in FP	; BCDE 1 (default STEP) per indice single
			LD D,C					; Copia C in D										; C=0
			LD E,D					; Copia D in E										; D=0
			LD A,(HL)				; Carica in A da memoria puntata da (HL)			; Get next byte in code string
			CP TKSTEP				; Compara A con il valore 0xCC (Token STEP), controlla presenza STEP		; See if "STEP" is stated
			LD A,0x01				; Carica in A il valore 0x01, segno di STEP			; Sign of step = 1
			JR NZ,L1D0F				; Se diverso, passa a 0x1D0F, nessuno STEP indicato	; No STEP given - Default to 1
			CALL L2338				; Chiama la 0x2338 (L2338 EVAL1)					; Jump over "STEP" token
			PUSH HL					; Salva HL nello stack
			CALL CSNG				; Chiama la 0x0AB1 (L0AB1 CSNG), converte STEP in FP	; Get step value
			CALL FPR2BCDE			; Chiama la 0x09BF (L09BF FPR2BCDE), converte FP in BCDE	; Move STEP to BCDE
			CALL TSTSGN				; Chiama la 0x0955 (L0955 TSTSGN)						; Test sign of FPREG
			;																							
L1D0E		POP HL					; Recupera HL dallo stack
L1D0F		PUSH BC					; Salva BC nello stack
			PUSH DE					; Salva DE nello stack
			LD C,A					; Copia A in C
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			LD B,A					; Copia A in B
			PUSH BC					; Salva BC nello stack
			PUSH HL					; Salva HL nello stack
			LD HL,(PCODE2RUN)		; Carica in HL da memoria puntata da (0x40DF) PCODE2RUN
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			;
L1D1A		LD B,0x81				; Carica in B il valore 0x81					; "FOR" block marker
			PUSH BC					; Salva BC nello stack							; Save it
			INC SP					; Incrementa SP									; Don't save C
									;   continua con la 0x1D1E (L1D1E RUNCNT)

			;
			; Routine 0x1D1E - RUNCNT
			;
RUNCNT		CALL GETK				; Chiama la 0x0358 (L0358 GETK)
			OR A					; Esegue OR di A
			CALL NZ,CTRLSW			; Se diverso da zero, chiama la 0x1DA0 (L1DA0 CTRLSW)
			LD (UNK03),HL			; Salva HL in memoria puntata da (0x40E6) UNK03
			LD (SPTMP),SP			; Salva SP in memoria puntata da (0x40E8) SPTMP
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CP ':'					; Compara A con il valore 0x3A (carattere ':')
			JR Z,EXCUTE				; Se uguale, passa a 0x1D5A (L1D5A EXCUTE)
			OR A					; Esegue OR di A
			JP NZ,SNERR				; Se diverso da zero, passa a 0x1997 (L1997 SNERR)
			INC HL					; Incrementa HL
L1D36		LD A,(HL)				; Carica in A da memoria puntata da (HL)
			INC HL					; Incrementa HL
			OR (HL)					; Esegue OR di A com memoria puntata da (HL)
			JP Z,ENDPRG				; Se zero, passa alla 0x197E (L197E ENDPRG)
			INC HL					; Incrementa HL
			LD E,(HL)				; Carica in E da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD D,(HL)				; Carica in D da memoria puntata da (HL)
			EX DE,HL				; Scambia DE ed HL
			LD (LINEAT),HL			; Salva HL in memoria puntata da (0x40A2) LINEAT
			LD A,(TRCVAL)			; Carica in A da memoria puntata da (0x411B) TRCVAL
			OR A					; Esegue OR di A
			JR Z,L1D59				; Se zero, passa a 0x1D59
			PUSH DE					; Salva DE nello stack
			LD A,'<'				; Carica in A il valore 0x3C (carattere '<')
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
			CALL PRNTHL				; Chiama la 0x0FAF (L0FAF PRNTHL)
			LD A,'>'				; Carica in A il valore 0x3E (carattere '>')
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
			POP DE					; Recupera DE dallo stack
L1D59		EX DE,HL				; Scambia DE ed HL
									;   continua con la 0x1D5A (L1D5A EXCUTE)
			
			;
			; Routine 0x1D5A - EXCUTE
			;
EXCUTE		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			LD DE,RUNCNT			; Carica in DE il valore 0x1D1E (puntatore a RUNCNT)
			PUSH DE					; Salva DE nello stack
L1D5F		RET Z					; Se zero, ritorna										; Go to RUNCNT if end of STMT
L1D60		SUB 0x80				; Sottrae da A il valore 0x80							; Is it a token?
			JP C,LET				; Se CY=1, passa a 0x1F21 (L1F21 LET)					; No - try to assign it
			CP 0x3C					; Compara A con il valore 0x3C							; END to NEW ?
			JP NC,L2AE7				; Se CY=0, passa a 0x2AE7
			RLCA					; Ruota A a sinistra di 1 bit							; Double it
			LD C,A					; Copia A in C											; BC = Offset into table
			LD B,0x00				; Azzera B
			EX DE,HL				; Scambia DE ed HL										; Save code string address
			LD HL,KWDTAB			; Carica in HL il valore 0x1822 (puntatore a KWDTAB)	; Keyword address table
			ADD HL,BC				; Somma BC ad HL										; Point to routine address
			LD C,(HL)				; Carica in C il valore puntato da (HL)					; Get LSB of routine address
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B il valore puntato da (HL)					; Get MSB of routine address
			PUSH BC					; Salva BC nello stack									; Save routine address
			EX DE,HL				; Scambia DE ed HL										; Restore code string address
									;   continua con la 0x1D78 (L1D78 GETCH)

			;
			; Routine 0x1D78 - GETCH  Legge carattere puntato da (HL+1)  (da RST 0x10)
			;   Input:  HL puntatore a carattere precedente
			;   Output: A carattere letto, Z se ':' o <NUL>, CY=0 se <'0' o >'9', 
			;
GETCH		INC HL					; Incrementa HL											; Point to next character
			LD A,(HL)				; Carica valore in A da (HL)							; Get next code string byte
			CP '9'+1				; Compara A con 0x3A (carattere ':', ovvero '9'+1)		; Z if ':'
			RET NC					; Se CY=0, ritorna 										; NC if > "9"
			CP ' '					; Compara A con 0x20 (carattere ' ')
			JP Z,GETCH				; Se uguale, passa a 0x1D78 (L1D78 GETCH)				; Skip over spaces
			CP 0x0B					; Compara A con 0x0B 
			JR NC,L1D8B				; Se CY=0, passa 0x1D8B									; CY=0 if > 0x0B
			CP CHTB					; Compara A con 0x09 (catattere <TAB>)					; Skip over <TAB>
			JP NC,GETCH				; Se CY=0, passa a 0x1D78 (L1D78 GETCH)
L1D8B		CP '0'					; Compara A con 0x30 (caratter '0')
			CCF     				; Inverte CY
			INC A					; Incrementa A											; Test for zero - Leave carry
			DEC A					; decrementa A											; Z if Null
			RET     				; Ritorna

			;
			; Routine 0x1D91 - RESTORE  Reset puntatori DATA		
			;
RESTORE		EX DE,HL				; Scambia DE ed HL											; Save code string address
			LD HL,(BASTXT)			; Carica in HL da memoria puntata da (0x40A4) BASTXT		; Point to start of program
			DEC HL					; Decrementa HL												; Byte before DATA statement
L1D96		LD (NXTDAT),HL			; Salva HL in memoria puntata da (0x40FF) NXTDAT			; Update DATA pointer NXTDAT
			EX DE,HL				; Scambia DE ed HL											; Restore code string address
			RET     				; Ritorna													
																										
			;																							
			; Routine 0x1D9B - TSTBRK
			;																							
L1D9B		CALL GETK				; Chiama la 0x0358 (L0358 GETK)
			OR A					; Esegue OR di A											
			RET Z					; Se zero, ritorna											
									;   altrimenti continua con la 0x1DA0 (L1DA0 CTRLSW)

			;
			; Routine 0x1DA0 - CTRLSW
			;
CTRLSW		CP CHCS					; Compara A con il valore 0x13 (tasto 0x13 <CTRLS>)			
			CALL Z,WTAKEY			; Se uguale, chiama la 0x0384 (L0384 WTAKEY)				; Stall
			LD (LSTKEY),A			; Salva A in memoria puntata da (0x4099) LSTKEY
			.BYTE 0xD6				; Esegue SUB 0x03, skip di INC BC
									;  continua con la 0x1DA9 (L1DA9)
			; 
			; Routine 0x1DA9 - STOP
			;
STOP		INC BC					; Incrementa BC
			RET NZ					; Se diverso da zero, ritorna
			INC A					; Incrementa A
			JR L1DB4				; Passa a 0x1DB4 (L1DB4 ?)
			
			;
			; Routine 0x1DAE - END
			;
END			RET NZ					; Se diverso da zero, ritorna
			PUSH AF					; Salva AF nello stack
			NOP						;
			NOP						;
			NOP						;
			POP AF					; Recuper AF dallo stack
L1DB4		LD (UNK03),HL			; Salva HL in memoria puntata da (0x40E6) UNK03
			LD HL,TSAREA			; Carica in HL il valore 0x40B5 (puntatore a TSAREA)		
			LD (TMSTPT),HL			; Salva HL in memoria puntata da (0x40B3) TMSTPT
			.BYTE 0x21				; Esegue LD HL,0xFFF6 skip OR 0xFF
									;   continua con 0x1DC0 (L1DC0)

			;
			; Routine 0x1DBE - INPBRK
			;
INPBRK		OR 0xFF					; Esegue OR di A con il valore 0xFF
L1DC0		POP BC					; Recupera BC dallo stack
L1DC1		LD HL,(LINEAT)			; Carica in HL memoria puntata da (0x40A2) LINEAT
			PUSH HL					; Salva HL nello stack
			PUSH AF					; Salva AF nello stack
			LD A,L					; Copia L in A
			AND H					; Esegue AND di A con H
			INC A					; Incrementa A
			JR Z,L1DD4				; Se zero, passa a 0x1DD4
			LD (0x40F5),HL			; Copia HL in memoria puntata da (0x40F5)
			LD HL,(UNK03)			; Carica in HL da memoria puntata da (0x40E6) UNK03
			LD (0x40F7),HL			; Salva HL in memoria puntata da (0x40F7)
L1DD4		CALL RESPRN				; Chiama la 0x038B (L038B RESPRN)
			CALL PRCRNZ				; Chiama la 0x20F9 (L20F9 PRCRNZ)
			POP AF					; Recupera AF dallo stack
			LD HL,MSGBRK			; Carica in HL il valore 0x1930 (puntatore a "Break")
			JP NZ,L1A06				; Se diverso da zero, passa a 0x1A06 (L1A06 ?)
			JP BASMAIN2				; Passa a 0x1A18 (L1A18 BASMAIN2)

			;
			; Routine 0x1DE4 - CONT
			;
CONT		LD HL,(0x40F7)			; Carica in HL da memoria puntata da (0x40F7)
			LD A,H					; Copia H in A
			OR L					; Esegue OR di A con L
			LD E,ECOD20				; Carica in E il valore 0x20 (codice errore Can'continue Error)
			JP Z,MSGERR				; Se zero, passa a 0x19A2 (L19A2 MSGERR)
			EX DE,HL				; Scambia DE ed HL
			LD HL,(0x40F5)			; Carica in HL da memoria puntata da (0x40F5)
			LD (LINEAT),HL			; Salva HL in memoria puntata da (0x40A2) LINEAT
			EX DE,HL				; Scambia DE ed HL
			RET						; Ritorna

			;
			; Routine 0x1DF7 - TRON
			;
TRON		.BYTE 0x3E				; Esegue LD A,0xAF, skip di XOR A
									;   contiuna con 0x1DF9 (L1DF9)
			;
			;
			; Routine 0x1DF8 - TROFF
			;
TROFF		XOR A					; Azzera A			
									;   contiuna con 0x1DF9 (L1DF9)
			;
L1DF9		LD (TRCVAL),A			; Salva A in memoria puntata da (0x411B) TRCVAL
			RET						; Ritorna

			;
			; Routine 0x1DFD
			;
L1DFD		POP AF					; Recupera AF dallo stack
			POP HL					; Recupera HL dallo stack
			RET						; Ritorna

			;
			; Routine 0x1E00 - DEFSTR
			;
DEFSTR		LD E,0x03				; Carica in E il valore 0x03  (lunghezza variabile stringa)
			.BYTE 0x01				; Esegue LD BC,0x031E  skip LD E,0x02
									;  continua alla 0x1E05 (L1E05)

			;
			; Routine 0x1E03 - DEFINT
			;
DEFINT		LD E,0x02				; Carica in E il valore 0x02 (lunghezza variabile intera)
L1E05		.BYTE 0x01				; Esegue LD BC,0x041E  skip LD E,0x04
									;  continua alla 0x1E08 (L1E08)
			;
			; Routine 0x1E06 - DEFSNG
			;
DEFSNG		LD E,0x04				; Carica in E il valore 0x04 (lunghezza variabile single)
L1E08		.BYTE 0x01				; Esegue LD BC,0x081E  skip LD E,0x08
									;  continua alla 0x1E0B (L1E0B DEFALL)

			;
			; Routine 0x1E09 - DEFDBL
			;
DEFDBL		LD E,0x08				; Carica in E il valore 0x08 (lunghezza variabile double)
DEFALL		CALL CHKLTR				; Chiama la 0x1E3D (L1E3D CHKLTR)
			LD BC,SNERR				; Carica in BC il valore 0x1997 (puntatore a SNERR)
			PUSH BC					; Salva BC nello stack
			RET C					; Se CY=1, non è una lettera, ritorna (L1997 SNERR)
			SUB 'A'					; Sottrae da A il valore 0x41 (carattere 'A')
			LD C,A					; Copia A in C
			LD B,A					; Copia A in B
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			CP TKMINUS				; Compara A con il valore 0xCE (token -) (per intevallo variabili)
			JR NZ,L1E25				; Se diverso da zero, passa a 0x1E25
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)	
			CALL CHKLTR				; Chiama la 0x1E3D (L1E3D CHKLTR)
			RET C					; Se CY=1, non è una lettera, ritorna (L1997 SNERR)
			SUB 'A'					; Sottrae da A il valore 0x41 (carattere 'A')
			LD B,A					; Copia A in B
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
L1E25		LD A,B					; Copia B in A
			SUB C					; Sottrae C da A
			RET C					; Se CY=1, ordine lettere non corretto, ritorna (L1997 SNERR)
			INC A					; Incrementa A
			EX (SP),HL				; Scambia HL con memoria puntata da (SP) (sostituisce rientro SNERR con HL)
			LD HL,DEFTVAR			; Carica in HL il valore 0x4101 (puntatore tabella tipo variabili DEFTVAR)	 
			LD B,0x00				; Azzera B
			ADD HL,BC				; Somma BC ad HL
L1E30		LD (HL),E				; Copia E in memoria puntata da (HL) (lunghezza variabile in posizione tabella DEFTVAR)
			INC HL					; Incrementa HL
			DEC A					; Decrementa A
			JR NZ,L1E30				; Se diverso da zero, passa a 0x1E30 (tutte le variabili del gruppo x-y)
									;
			POP HL					; Recupera HL dallo stack
			LD A,(HL)				; Caria in A memoria puntata da (HL)
			CP ','					; Compara A con il valore 0x2C (carattere ',')
			RET NZ					; Se diverso da zero, ritorna
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			JR DEFALL				; Passa a 0x1E0B (L1E0B DEFALL), continua valutazione prossimo gruppo

			; 
			; Routine 0x1E3D - CHKLTR  Test di carattere alfabetico puntato da (HL)
			;   Input: HL puntatore a carattere
			;  Output: CY
			;
CHKLTR		LD A,(HL)				; Carica in A da memoria puntata da (HL)	
									;   continua con 0x1E3E (L1E3E CKALTR)

			;
			; Routine 0x1E3E - CKALTR  Test di carattere alfabetico in A
			;   Input: A carattere
			;  Output: CY
			;
L1E3E		CP 'A'					; Compara A con il valore 0x41 (carattere 'A')
			RET C					; Se CY=1, ritorna
			CP 'Z'+1				; Compara A con il valore 0x5B (carattere '[')
			CCF     				; Complementa CY
			RET     				; Termina

			;
			; Routine 0x1E45 - FPSINT  Get subscript (0-32767)
			;			
FPSINT		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)		
L1E46		CALL GETSINT			; Chiama la 0x2B02 (L2B02 GETSINT)
			RET P					; Se positivo, ritorna
									;  altrimenti continua con 0x1E4A (L1E4A IFERR)

			; 
			; Routine 0x1E4A - IFERR Illegal Function Call Error
			;
IFERR		LD E,ECOD08				; Carica in E il valore 0x08 (codice errore Illegal Function Call Error)
			JP MSGERR				; Chiama la 0x19A2 (L19A2 MSGERR)
			
			;
			; Routine 0x1E4F -  GETVALDE  Ottiene valore in DE?
			;   Output: DE valore intero
			;
GETVALDE	LD A,(HL)				; Carica in A memoria puntata da (HL)
			CP '.'					; Compara A con il valore 0x2E (carattere '.')
			EX DE,HL				; Scambia DE ed HL
			LD HL,(CUREDLN)			; Carica in HL da memoria puntata da (0x40EC) CUREDLN
			EX DE,HL				; Scambia DE ed HL
			JP Z,GETCH				; Se zero, passa a 0x1D78 (L1D78 GETCH)
									;   altrimenti continua con 0x1E5A (L1E5A ATOH)

			;
			; Routine 0x1E5A - ATOH  Ottiene numero di linea in DE da carattere precedente
			;
ATOH		DEC HL					; Decrementa HL

			;
			; Routine 0x1E5B - GETLN  Ottiene numero di linea in DE
			;    Output: DE numero di linea   A prossimo carattere
			;
GETLN		LD DE,0x0000			; Azzera DE
			; 
GETLNP		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			RET NC					; Se CY=0, ritorna
			PUSH HL					; Salva HL nello stack
			PUSH AF					; Salva AF nello stack
			LD HL,0x1998			; Carica in HL il valore 0x1998
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JP C,SNERR				; Se CY=1, passa a 0x1997 (L1997 SNERR)
			LD H,D					; Copia D in H			
			LD L,E					; Copia E in L
			ADD HL,DE				; Somma DE ad HL
			ADD HL,HL				; Raddoppia HL
			ADD HL,DE				; Somma DE ad HL
			ADD HL,HL				; Raddoppia HL
			POP AF					; Recupera AF dallo stack
			SUB 0x30				; Sottrae da A il valore 0x30
			LD E,A					; Copia A in E
			LD D,0x00				; Azzera D
			ADD HL,DE				; Somma DE ad HL
			EX DE,HL				; Scambia DE ed HL
			POP HL					; Recupera HL dallo stack
			JR GETLNP				; Passa a 0x1E5E (L1E5E GETLNP)
			
			;
			; Routine 0x1E7A - CLEAR
			;
CLEAR		JP Z,L1B61				; Se zero, passa a 0x1B61 (L1B61 ?)
			CALL L1E46				; Chiama la 0x1E46 (L1E46 ?)
			DEC HL					; Decrementa HL
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			RET NZ					; Se diverso da zero, ritorna
			PUSH HL					; Salva HL nello stack
			LD HL,(EOFRAM)			; Carica in HL da memoria puntata da (0x40B1) EOFRAM	; Get End of RAM EOFRAM
			LD A,L					; Copia L in A
			SUB E					; Sottrae E da A
			LD E,A					; Copia A in E
			LD A,H					; Copia H in A
			SBC A,D					; Sottrae D da A
			LD D,A					; Copia A in D
			JP C,OMERR				; Se CY=1, passa a 0x197A (L197A OMERR)
			LD HL,(PRGEND)			; Carica in HL da memoria puntata da (0x40F9) PRGEND	; Get program end 
			LD BC,0x0028			; Carica in BC il valore 0x0028							; 40 Bytes minimum working RAM
			ADD HL,BC				; Somma BC ad HL										; Get lowest address
			RST VCPDEHL				; Chiama la RST 0x18 (Compara HL con DE CPDEHL)			; Enough memory?
			JP NC,OMERR				; Se CY=0, passa a 0x197A (L197A OMERR)					; No - ?OM Error
			EX DE,HL				; Scambia DE ad HL										; RAM top to HL
			LD (STRSPC),HL			; Salva HL in memoria puntata da (0x40A0) STRSPC		; Set new string space STRSPC
			POP HL					; Recupera HL dallo stack								; Restore code string address
			JP L1B61				; Passa a 0x1B61 (L1B61 INTVAR)							; Initialise variables
																								
			;																					
			; Routine 0x1EA3 - RUN
			;
RUN			JP Z,RUNFST				; Se zero, passa a 0x1B5D (L1B5D RUNFST)
			NOP     				;
			NOP     				;
			NOP     				;
			CALL L1B61				; Chiama la 0x1B61 (L1B61 INTVAR)
			LD BC,RUNCNT			; Carica in BC il valore 0x1D1E (puntatore a L1D1E RUNCNT)
			JR RUNLIN				; Passa a 0x1EC1 (L1EC1 RUNLIN)

			;
			; Routine 0x1EB1 - GOSUB
			;
GOSUB		LD C,0x03				; Carica in C il valore 0x03, test per 3 livelli di stack
			CALL CHKSTK				; Chiama la 0x1963 (L1963 CHKSTK)
			POP BC					; Recupera BC dallo stack
			PUSH HL					; Salva HL nello stack
			PUSH HL					; Salva HL nello stack
			LD HL,(LINEAT)			; Carica in HL memoria puntata da (0x40A2) LINEAT
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			LD A,TKGOSUB			; Carica in A il valore 0x91 (Token GOSUB)			; "GOSUB" token
			PUSH AF					; Salva AF nello stack								; Save token
			INC SP					; Incrementa SP										; Don't save flags
									;   continua con 0x1EC1 (L1EC1 RUNLIN)

			;
			; Routine 0x1EC1 - RUNLIN
			;
RUNLIN		PUSH BC					; Salva BC nello stack
									;  continua con 0x1EC2 (L1EC2 GOTO)
			
			;
			; Routine 0x1EC2 - GOTO
			;
GOTO		CALL ATOH				; Chiama la 0x1E5A (L1E5A ATOH)						; ASCII number to DE binary
L1EC5		CALL REM				; Chiama la 0x1F07 (L1F07 REM)						; Get end of line
			PUSH HL					; Salva HL nello stack								; Save end of line
			LD HL,(LINEAT)			; Carica in HL da memoria puntata da (0x40A2)		; Get current line LINEAT
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)				; Line after current?
			POP HL					; Recupera HL dallo stack							; Restore end of line
			INC HL					; Incrementa HL										; Start of next line
			CALL C,SRCHLP			; Se CY=1, chiama la 0x1B2F (L1B2F SRCHLP)			; Line is after current line SRCHLP
			CALL NC,SRCHLN			; Se CY=0, chiama la 0x1B2C (L1B2C SRCHLN)			; Line is before current line SRCHLN
			LD H,B					; Copia B in H 										; Set up code string address
			LD L,C					; Copia C in L 
			DEC HL					; Decrementa HL										; Incremented after
			RET C					; Se CY=1, ritorna									; Line found
									;   altrimenti passa alla 0x1ED9 (L1ED9 ULERR)

			;
			; Routine 0x1ED9 - ULERR  Errore Undefined Line Number
			;
ULERR		LD E,0x0E				; Carica in E il valore 0x0E						; UL Error
			JP MSGERR				; Chiama la 0x19A2 (L19A2 MSGERR)					; Output error message

			;
			; Routine 0x1EDE - RETURN
			;
RETURN 		RET NZ					; Se diverso da zero, ritorna							; Return if not just RETURN
			LD D,0xFF				; Carica in D il valore 0xFF (flag GOSUB)				; Flag "GOSUB" search
			CALL LKFORGOSUB			; Chiama la 0x1936 (L1936 LKFORGOSUB), cerca blocchi GOSUB attivi ; Look "GOSUB" block
			LD SP,HL				; Copia HL in SP										; Kill all FORs in subroutine
			LD (SPTMP),HL			; Salva HL in memoria puntata da (0x40E8) SPTMP
			CP TKGOSUB				; Compara A con il valore 0x91 (token GOSUB)			; Test for "GOSUB" token
			LD E,ECOD04				; Carica in E il valore 0x04 (codice errore Return Without Gosub)
			JP NZ,MSGERR			; Se diverso da zero, passa a 0x19A2 (L19A2 MSGERR)		; Error if no "GOSUB" found
			POP HL					; Recupera HL dallo stack								; Get RETURN line number
			LD (LINEAT),HL			; Salva HL in memoria puntata da (0x40A2)				; Save as current LINEAT
			INC HL					; Incrementa HL											; Was it from direct statement?
			LD A,H					; Copia H in A
			OR L					; Esegue OR di A con L									; Return to line
			JR NZ,L1EFF				; Se diverso da zero, passa a 0x1EFF					; No - Return to line
			LD A,(LSTBIN)			; Carica in A memoria puntata da (0x40DD) LSTBIN		; Any INPUT in subroutine?
			OR A					; Esegue OR di A										; If so buffer is corrupted
			JP NZ,BASMAIN2			; Se diverso da zero passa a 0x1A18 (L1A18 BASMAIN2)	; Yes - Go to command mode
L1EFF		LD HL,RUNCNT			; Carica in HL il valore 0x1D1E	(RUNCNT)				; Execution driver loop
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)				; Into stack - Code string out
			.BYTE 0x3E				; Esegue LD A,0xE1 skip POP HL											; Skip "POP HL"
									;   continua con 0x1F05 (L1F05 DATA)

			;
			; Routine 0x1F04 - NXTDTA
			;
L1F04		POP HL					; Recupera HL dallo stack								; Restore code string address
			
			;
			; Routine 0x1F05 - DATA
			;
DATA		.BYTE 0x01, 0x3A		; Esegue LD BC,0x0E3A e NOP skip LD C,0x00
									;   continua con 0x1F09 (L1F09)

			;
			; Routine 0x1F07 - REM, ELSE
			;
REM			;
ELSE		LD C,0x00				; Azzera C											; 00 End of statement
L1F09		LD B,0x00				; Azzera B											
L1F0B		LD A,C					; Copia C in A										; Statement and byte
			LD C,B					; Copia B in C										
			LD B,A					; Copia A in B										; Statement end byte
L1F0E		LD A,(HL)				; Carica in A da memoria puntata da (HL)			; Get byte			
			OR A					; Esegue OR di A									; End of line?
			RET Z					; Se zero, ritorna									; Yes - Exit  
			CP B					; Compara A con B									; End of statement?
			RET Z					; Se zero, ritorna									; Yes - Exit  
			INC HL					; Incrementa HL										; Next byte   
			CP 0x22					; Compara A con il valore 0x22 (carattere '"')		; Literal string?
			JR Z,L1F0B				; Se uguale, passa a 0x1F0B							; Yes - Look for another '"'
			SUB 0x8F					; Sottrae da A il valore 0x8F
			JR NZ,L1F0E				; Se diverso da zero, passa a 0x1F0E
			CP B					; Compara A con B
			ADC A,D					; Somma D ad A
			LD D,A					; Copia A in D
			JR L1F0E				; Passa a 0x1F0E (L1F0E), loop

			;
			; Routine 0x1F21 - LET
			;
LET			CALL GETVAR				; Chiama la 0x260D (L260D GETVAR)
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE TKEQUAL			; (Token =)
			EX DE,HL				; Scambia DE ed HL
			LD (PCODE2RUN),HL		; Salva HL in memoria puntata da (0x40DF) PCODE2RUN
			EX DE,HL				; Scambia DE ed HL
L1F2B		PUSH DE					; Salva DE nello stack
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			PUSH AF					; Salva AF nello stack
			CALL EVAL				; Chiama la 0x2337 (L2337 EVAL)
			POP AF					; Recupera AF dallo stack
L1F32		EX (SP),HL				; Scambia HL e memoria puntata da (SP)
L1F33		ADD A,0x03				; Somma ad A il valore 0x03
			CALL EXECCV				; Chiama la 0x2819 (L2819 EXECCV)
			CALL L0A03				; Chiama la 0x0A03 (L0A03 ?)
			PUSH HL					; Salva HL nello stack
			JR NZ,L1F66				; Se diverso da zero, passa a 0x1F66 
			LD HL,(FPREG)			; Carica in HL da memoria puntata da (0x4121) FPREG
			PUSH HL					; Salva HL nello stack
			INC HL					; Incrementa HL
			LD E,(HL)				; Carica in E da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD D,(HL)				; Carica in D da memoria puntata da (HL)
			LD HL,(BASTXT)			; Carica in HL da memoria puntata da (0x40A4) BASTXT
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR NC,L1F5A				; Se CY=0, passa a 0x1F5A
			LD HL,(STRSPC)			; Carica in HL da memoria puntata da (0x40A0) STRSPC
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			POP DE					; Recupera DE dallo stack
			JR NC,L1F62				; Se CY=0, passa a 0x1F62
			LD HL,(PRGEND)			; Carica in HL da memoria puntata da (0x40F9) PRGEND
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR NC,L1F62				; Se CY=0, passa a 0x1F62
			.BYTE 0x3E				; Esegue LD A,0xD1 skip istruzione POP DE
									;  continua con 0x1F5B (L1F5B)
									;
L1F5A		POP DE					; Recuper DE dallo stack
L1F5B		CALL L29F5				; Chiama la 0x29F5 (L29F5 ?)
			EX DE,HL				; Scambia DE ed HL
			CALL L2843				; Chiama la 0x2843 (L2843 ?)
L1F62		CALL L29F5				; Chiama la 0x29F5 (L29F5 ?)
			EX (SP),HL				; Scambia HL e memoria puntata da (SP)
L1F66		CALL CPYVDEHL				; Chiama la 0x09D3 (L09D3 CPYVDEHL)
			POP DE					; Recupera DE dallo stack
			POP HL					; Recupera HL dallo stack
			RET						; Ritorna

			;
			; Routine 0x1F6C - ON
			;
ON			CP TKERROR				; Compara A con il valore 0x9E (Token ERROR)
			JR NZ,L1F95				; Se diverso, passa a 0x1F95
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE TKGOTO			; (Token GOTO)
			CALL ATOH				; Chiama la 0x1E5A (L1E5A ATOH)
			LD A,D					; Copia D in A
			OR E					; Esegue OR di A con E
			JR Z,L1F83				; Se zero, passa a 0x1F83 (ON ERROR GOTO 0)
			CALL L1B2A				; Chiama la 0x1B2A (L1B2A SRCHLN2)
			LD D,B					; Copia B in D
			LD E,C					; Copia C in E
			POP HL					; Recupera HL dallo stack
			JP NC,ULERR				; Se CY=0, passa alla 0x1ED9 (L1ED9 ULERR)
L1F83		EX DE,HL				; Scambia DE ed HL
			LD (ONERLN),HL			; Salva HL in memoria puntata da (0x40F0) ONERLN
			EX DE,HL				; Scambia DE ed HL
			RET C					; Se CY=1, ritorna
			LD A,(RESACT)			; Carica in A da memoria puntata da (0x40F2) RESACT
			OR A					; Esegue OR di A
			RET Z					; Se zero, ritorna
			LD A,(CURERR)			; Carica in A da memoria puntata da (0x409A) CURERR
			LD E,A					; Copia A in E
			JP L19AB				; Passa a 0x19AB (L19AB ?)
			;
L1F95		CALL GETBYT				; Chiama la 0x2B1C (L2B1C GETBYT)			; Get integer 0-255
			LD A,(HL)				; Carica in A da memoria puntata da (HL)	; Get "GOTO" or "GOSUB" token
			LD B,A					; Copia A in B								; Save in B
			CP TKGOSUB				; Compara A con il valore 0x91 (Token GOSUB); "GOSUB" token?
			JR Z,L1FA1				; Se uguale, passa a 0x1FA1					; Yes - Find line number
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)		; Make sure it's "GOTO"
			.BYTE TKGOTO			; (Token GOTO)								; "GOTO" token
			DEC HL					; Decrementa HL								; Cancel increment
L1FA1		LD C,E					; Copia E in C								; Integer of branch value
L1FA2		DEC C					; Decrementa C								; Count branches
			LD A,B					; Copia C in A								; Get "GOTO" or "GOSUB" token
			JP Z,L1D60				; Se zero, passa a 0x1D60 (L1D60 ?)			; Go to that line if right one
			CALL GETLN				; Chiama la 0x1E5B (L1E5B GETLN)			; Get line number to DE
			CP 0x2C					; Compara A con il valore 0x2C (carattere ',')	; Another line number?
			RET NZ					; Se diverso, ritorna						; No - Drop through
			JR L1FA2				; Passa a 0x1FA2, ripete ciclo				; Yes - loop

			;
			; Routine 0x1FAF - RESUME
			;
RESUME		LD DE,RESACT			; Carica in DE il valore 0x40F2 (puntatore a RESACT)
			LD A,(DE)				; Carica in A da memoria puntata da (DE)
			OR A					; Esegue OR di A
			JP Z,RWERR				; Se zero, passa a 0x19A0 (L19A0 RWERR)			; Resume Without Error
			INC A					; Incrementa A
			LD (CURERR),A			; Salva A in memoria puntata da (0x409A) CURERR
			LD (DE),A				; Salva A in memoria puntata da (DE)
			LD A,(HL)				; Carica in A memoria puntata da (HL)
			CP TKNEXT				; Compara A con il valore 0x87 (Token NEXT)
			JR Z,L1FCD				; Se uguale, passa a 0x1FCD
			CALL ATOH				; Chiama la 0x1E5A (L1E5A ATOH)
			RET NZ					; Se diverso da zero, ritorna
			LD A,D					; Copia D in A
			OR E					; Esegue OR di A con E
			JP NZ,L1EC5				; Se diverso da zero, passa a 0x1EC5 (L1EC5 ?)
			INC A					; Incrementa A
			JR L1FCF				; Passa a 0x1FCF
L1FCD		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			RET NZ					; Se diverso da zero, ritorna
L1FCF		LD HL,(UNK04)			; Carica in HL memoria puntata da (0x40EE) UNK04
			EX DE,HL				; Scambia DE ed HL
			LD HL,(CURERL)			; Carica in HL da memoria puntata da (0x CURERL
			LD (LINEAT),HL			; Salva HL in memoria puntata da (0x40A2)
			EX DE,HL				; Scambia DE ed HL
			RET NZ					; Se diverso da zero, ritorna
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			OR A					; Esegue OR con A
			JR NZ,L1FE3				; Se diverso da zero, passa alla 0x1FE3 (L1FE3 ?)
			INC HL					; Incrementa HL
			INC HL					; Incrementa HL
			INC HL					; Incrementa HL
			INC HL					; Incrementa HL
L1FE3		INC HL					; Incrementa HL
			LD A,D					; Copia D in A
			AND E					; Esegue AND di E con A
			INC A					; Incrementa A
			JP NZ,DATA				; Se diverso da zero, passa alla 0x1F05 (L1F05 DATA)
			LD A,(LSTBIN)			; Carica in A da memoria puntata da (0x40DD) LSTBIN
			DEC A					; Decrementa A
			JP Z,INPBRK				; Se zero, passa alla 0x1DBE (L1DBE INPBRK)
			JP DATA					; Passa alla 0x1F05 (L1F05 DATA)

			;
			; Routine 0x1FF4 - ERROR
			;
ERROR		CALL GETBYT				; Chiama la 0x2B1C (L2B1C GETBYT)
			RET NZ					; Se diverso da zero, ritorna
			OR A					; Esegue OR di A
			JP Z,IFERR				; Se zero, passa alla 0x1E4A (L1E4A IFERR)
			DEC A					; Decrementa A
			ADD A,A					; Raddoppia A
			LD E,A					; Copia A in E
			CP 0x2D					; Compara A con il valore 0x2D
			JR C,L2005				; Se CY=1, passa a 0x2005
			LD E,ECOD26				; Carica in E il valore 0x26 (codice errore Unprintable)
L2005		JP MSGERR				; Chiama la 0x19A2 (L19A2 MSGERR)

			;
			; Routine 0x2008 - AUTO
			;
AUTO		LD DE,0x000A			; Carica in DE il valore 0x000A (passo standard)
			PUSH DE					; Salva DE nello stack
			JR Z,L2025				; Se zero, passa a 0x2025 (comando senza parametri)
			;
			CALL GETVALDE			; Chiama la 0x1E4F (L1E4F GETVALDE)
			EX DE,HL				; Scambia DE ed HL
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			JR Z,L2026				; Se zero, passa a 0x2026
			EX DE,HL				; Scambia DE ed HL
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','				; (carattere ',')
			EX DE,HL				; Scambia DE ed HL
			LD HL,(AUTOSTEP)		; Cariva in HL da memoria puntata da (0x40E4) AUTOSTEP
			EX DE,HL				; Scambia DE ed HL
			JR Z,L2025				; Se zero, passa a 0x2025
			CALL ATOH				; Chiama la 0x1E5A (L1E5A ATOH)
			JP NZ,SNERR				; Se diverso da zero, passa a 0x1997 (L1997 SNERR)
			;
L2025		EX DE,HL				; Scambia DE ed HL
L2026		LD A,H					; Copia H in A
			OR L					; Esegue OR di A con L
			JP Z,IFERR				; Se zero, passa alla 0x1E4A (L1E4A IFERR) (passo 0 non consentito)
			LD (AUTOSTEP),HL		; Salva HL in memoria puntata da (0x40E4) AUTOSTEP
			LD (AUTOACT),A			; Salva A in memoria puntata da (0x40E1)
			POP HL					; Recupera HL dallo stack
			LD (AUTONXTL),HL		; Copia HL in memoria puntata da (0x40E2) AUTONXTL
			POP BC					; Recupera BC dallo stack
			JP GETCMD				; Passa alla 0x1A33 (L1A33 GETCMD)

			; 
			; Routine 0x2039 - IF
			;
IF			CALL EVAL				; Chiama la 0x2337 (L2337 EVAL)
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CP 0x2C					; Compara A con il valore 0x2C (carattere ',')
			CALL Z,GETCH			; Se uguale, chiama la 0x1D78 (L1D78 GETCH)
			CP TKTHEN				; Compara A con il valore 0xCA (Token THEN)
			CALL Z,GETCH			; Se uguale, chiama la 0x1D78 (L1D78 GETCH)
			DEC HL					; Decrementa HL
			PUSH HL					; Salva HL nello stack
			CALL L0994				; Chiama la 0x0994 (L0994 TSTSGNNUM)
			POP HL					; Recupera HL dallo stack
			JR Z,L2056				; Se zero, passa a 0x2056
L204F		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			JP C,GOTO				; Se CY=1, passa alla 0x1EC2 (L1EC2 GOTO)
			JP L1D5F				; Passa a 0x1D5F (L1D5F ?)
L2056		LD D,0x01				; Carica in D il valore 0x01
L2058		CALL DATA				; Chiama la 0x1F05 (L1F05 DATA)
			OR A					; Esegue OR di A
			RET Z					; Se zero, ritorna
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			CP TKELSE				; Compara A con il valore 0x95 (Token ELSE)
			JR NZ,L2058				; Se diverso, passa a 0x2058
			DEC D					; Decrementa D
			JR NZ,L2058				; Se diverso, passa a 0x2058
			JR L204F				; Passa a 0x204F
			
			;
			; Routine 0x2067 - LPRINT
			;
LPRINT		LD A,0x01				; Carica in A il valore 0x01 (uscita su stampante)
			LD (DEVOUT),A			; Salva A in memoria puntata da (0x409C) DEVOUT
			JP PTODEV				; Passa alla 0x209B (L209B PTODEV)

			;
			; Routine 0x206F - PRINT
			;
PRINT		NOP						;
			NOP						;
			NOP						;
			CP '@'					; Compara A con il valore 0x40 (carattere '@')
			JR NZ,PNOCOO			; Se diverso, passa a 0x208F, non sono indicate coordinate
									; Coordinate presenti
			CALL GETNSINT			; Chiama la 0x2B01 (L2B01 GETNSINT), legge in intero con segno
			CP 0x02					; Compara A con il valore 0x02, numero a due cifre
			JP NC,IFERR				; Se CY=0, passa alla 0x1E4A (L1E4A IFERR), Illegal function error
			PUSH HL					; Salva HL nello stack
			LD HL,VIDBASE			; Carica in HL il valore 0xEC00 (puntatore base memoria video VIDBASE)
			ADD HL,DE				; Somma DE ad HL, valore colonna sommata a base video
			LD (SCRCURR),HL			; Salva HL in memoria puntata da (0x4020) SCRCURR
			LD A,E					; Copia E in A
			AND 0x3F				; Esegue la AND di A con il valore 0x3F (posizione nelle due righe)
			LD (CURPOS),A			; Salva A in memoria puntata da (0x40A6) CURPOS
			POP HL					; Recupera HL dallo stack
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','				; (Carattere ',')
			;
PNOCOO		CP '#'					; Compara A con il valore 0x23 (carattere '#')
			JR NZ,PTODEV			; Se diverso da zero, passa a L209B, non è indicato canale di output
									; Canale di output presente
			CALL VOUTTAP			; Chiama la 0x0284 (L0284 VOUTTAP)
			LD A,0x80				; Carica in A il valore 0x80 (uscita su tape)
			LD (DEVOUT),A			; Salva A in memoria puntata da (0x409C) DEVOUT
			;
PTODEV		DEC HL					; Decrementa HL												; DEC 'cos GETCHR INCs
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)	; Get next character
			CALL Z,PRNTCR			; Se zero, chiama la 0x20FE (L20FE PRNTCR)					; CR if just PRINT
			; 
PRNTLP		JP Z,SETDEFVID			; Se zero, passa a 0x2169 (L2169 SETDEFVID)					; End of print list - Exit
			;
			CP TKTAB				; Compara A con il valore 0xBF (token TAB()					; "TAB(" token?
			JP Z,TAB				; Se uguale, passa a 0x2CBD (L2CBD TAB)						; Yes - Do TAB routine
			CP TKSPC				; Compara A con il valore 0xBC (token SPC()					; "SPC(" token?
			JP Z,SPC				; Se uguale, passa a 0x2137 (L2137 SPC)						; Yes - Do SPC routine
			;
			PUSH HL					; Salva HL nello stack										; Save code string address
			CP ','					; Compara A con il valore 0x2C (carattere ',')				; Comma?
			JP Z,DOCOM				; Se uguale, passa a 0x2108 (L2108 DOCOM)					; Yes - Move to next zone
			;
			CP ';'					; Compara A con il valore 0x3B (carattere ';')				; Semi-colon?
			JP Z,NEXITM				; Se uguale, passa a 0x2164 (L2164 NEXITM)					; Do semi-colon routine
			;
			POP BC					; Recupera BC dallo stack									; Code string address to BC
			CALL EVAL				; Chiama la 0x2337 (L2337 EVAL)								; Evaluate expression
			PUSH HL					; Salva HL nello stack										; Save code string address
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)						; Get variable type
			JR Z,PRSTR				; Se zero, passa alla 0x20F2 (L20F2 PRSTR) Stringa ; Is it a string variable? Yes - Output string contents
			;
PASM		CALL NUMASC				; Chiama la 0x0FBD (L0FBD NUMASC), converte numero in stringa
			CALL CRTST				; Chiama la 0x2865 (L2865 CRTST)							; Create temporary string
			NOP     				;															
			NOP     				;															
			NOP						;
			LD HL,(FPREG)			; Carica in HL da memoria puntata da (0x4121) FPREG			
			LD A,(DEVOUT)			; Carica in A da memoria puntata da (0x409C) DEVOUT
			OR A					; Esegue OR di A											
			JP M,L20E9				; Se negativo, out su tape, passa a 0x20E9 (L20E9 ?)
			JR Z,L20DD				; Se zero, out su video, passa a 0x20DD (L20DD ?)
			LD A,(CPOSPRN)			; Carica in A da memoria puntata da (0x409B) CPOSPRN, out su stampante
			ADD A,(HL)				; Somma ad A memoria puntata da (HL)
			CP 0x84					; Compara A con il valore 0x84						
			JR 0x20E6				; Passa alla 0x20E6
			;
L20DD		LD A,(PLEN)				; Carica in A da memoria puntata da (0x409D) PLEN
			LD B,A					; Copia A in B
			LD A,(CURPOS)			; Carica in A da memoria puntata da (0x40A6) CURPOS
			ADD A,(HL)				; Somma ad A memoria puntata da (HL)
			CP B					; Compara A con B
L20E6		CALL NC,PRNTCR			; Se CY=0, passa a 0x20FE (L20FE PRNTCR)
L20E9		CALL PRSHL				; Chiama la 0x28AA (L28AA PRSHL)
			LD A,' '				; Carica in A il valore 0x20, carattere ' '
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
			OR A					; Esegue OR di A
PRSTR		CALL Z,PRSHL			; Se zero, chiama la 0x28AA (L28AA PRSHL)
			POP HL					; Recupera HL dallo stack
			JP PTODEV				; Passa a 0x209B (L209B PTODEV), ripete

			;
			; Routine 0x20F9 - PRCRNZ  Visualizza un CR se CURPOS non è zero
			;
PRCRNZ 		LD A,(CURPOS)			; Carica in A da memoria puntata da (0x40A6) CURPOS
			OR A					; Esegue OR di A
			RET Z					; Se zero, ritorna
									;  altrimenti continua con 0x20FE (L20FE PRNTCR)
			
			;
			; Routine 0x20FE - PRNTCR  Out di un CR
			;
PRNTCR		LD A,CHCR				; Carica in A il valore 0x0D (Carattere <CR>)
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
L2103		NOP     				;
			NOP     				;
			NOP     				;
			XOR A					; Azzera A
			RET     				; Ritorna

			;
			; Routine 0x2108 - DOCOM  Passa alla prossima zona colonna video
			;
DOCOM		NOP						;
			NOP						;
			NOP						;
			LD A,(DEVOUT)			; Carica in A da memoria puntata da (0x409C) DEVOUT
			OR A					; Esegue OR di A
			JP P,L2119				; Se positivo, passa a 0x2119
			LD A,','				; Carica in A il valore 0x2C (carattere ',')
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
			JR NEXITM				; Passa a 0x2164 (L2164 NEXITM)
			;
L2119		JR Z,L2123				; Se zero, passa a 0x2123
			LD A,(CPOSPRN)			; Carica in B da memoria puntata da (0x409B) CPOSPRN
			CP 0x70					; Compara A con il valore 0x70
			JP L212B				; Passa a 0x212B
			;
L2123		LD A,(COMMAW)			; Carica in A da memoria puntata da (0x409E) COMMAW				; Get comma width
			LD B,A					; Copia A in B													; Save in B
			LD A,(CURPOS)			; Carica in A da memoria puntata da (0x40A6) CURPOS				; Get current position
			CP B					; Compara A con B												; Within the limit?
L212B		CALL NC,PRNTCR			; Se CY=0, passa a 0x20FE (L20FE PRNTCR)						; No - output CRLF (only CR)
			JR NC,NEXITM			; Se CY=0, passa a 0x2164 (L2164 NEXITM)						; Get next item
L2130		SUB 0x10				; Sottrae da A il valore 0x10									; Next zone of 16 characters
			JR NC,L2130				; Se CY=0, passa a 0x2130										; Repeat if more zones
			CPL     				; Complementa A													; Number of spaces to output
			JR L215A				; Passa a 0x215A (L215A ASPCS)										; Output them

			;
			; Routine 0x2137 - SPC
			;
SPC			CALL L2B1B				; Chiama la 0x2B1B (L2B1B FNDNUM)
			AND 0x1F				; Esegue AND di A con il valore 0x1F
			LD E,A					; Copia A in E
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ')'				; (carattere ')')
			DEC HL					; Decrementa HL
			PUSH HL					; Salva HL nello stack
			NOP						;
			NOP						;
			NOP						;
			LD A,(DEVOUT)			; Carica in A da memoria puntata da (0x409C) DEVOUT
			OR A					; Esegue OR di A
			JP M,IFERR				; Se negativo, passa alla 0x1E4A (L1E4A IFERR)
			JP Z,L2153				; Se zero, passa a 0x2153
			LD A,(CPOSPRN)			; Carica in A memoria puntata da (0x409B) CPOSPRN
			JR L2156				; Passa a 0x2156
L2153		LD A,(CURPOS)			; Carica in A memoria puntata da (0x40A6) CURPOS
L2156		CPL						; Complementa A
			ADD A,E					; Somma E ad A
			JR NC,NEXITM			; Se CY=0, passa alla 0x2164 (L2164 NEXITM)
									;   altrimenti continua con la 0x215A (L215A ASPCS)

			;
			; Routine 0x215A - ASPCS  Visualizza un numero di spazi indicati in A
			;  Input: A  numero spazi da visualizzare
			;
L215A		INC A					; Incrementa A
			LD B,A					; Copia A in B
			LD A,' '				; Carica in A il valore 0x20, carattere ' '
L215E		CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
			DEC B					; Decrementa B
			JR NZ,L215E				; Se diverso da zero, passa a 0x215E
									;   altrimenti continua con 0x2164 (L2164 NEXITM)
			
			;
			; Routine 0x2164 - NEXITM
			;
NEXITM		POP HL					; Recupera HL dallo stack
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			JP PRNTLP				; Passa alla 0x20A0 (L20A0 PRNTLP)

			;
			; Routine 0x2169 - SETDEFVID  reset device uscita su video
			;
SETDEFVID	LD A,(DEVOUT)			; Carica in A da memoria puntata da (0x409C) DEVOUT
			OR A					; Esegue OR di A
			CALL M,DELS18			; Se minore di zero (0x80), chiama la 0x01F5 (L01F5 DELS18)
			XOR A					; Azzera A (uscita su video)
			LD (DEVOUT),A			; Azzera memoria puntata da (0x409C) DEVOUT
			NOP     				;
			NOP     				;
			NOP     				;
			RET     				; Ritorna

MREDO		.TEXT '?REDO', 0x0D, 0x00

			;
			; Routine 0x217F - BADINP
			;
L217F		LD A,(READFG)			; Carica in A da memoria puntata da (0x40DE) READFG					; READ or INPUT?
			OR A					; Esegue OR di A
			JP NZ,DATSNR			; Se diverso da zero, passa a 0x1991 (L1991 DATSNR)					; READ - ?SN Error
			LD A,(0x40A9)			; Carica in A da memoria puntata da (0x40A9)					
			OR A					; Esegue OR di A												
			LD E,ECOD2A				; Carica in E il valore 0x2A (codice errore Bad File Data)
			JP Z,MSGERR				; Se zero, passa a 0x19A2 (L19A2 MSGERR)								
			POP BC					; REcupera BC dallo stack											; Throw away code string addr
			LD HL,MREDO				; Carica in HL il valore 0x2178 (messaggio '?REDO')					; "Redo from start" message
			CALL PRS				; Chiama la 0x28A7 (L28A7 PRS)										; Output string
			LD HL,(UNK03)			; Carica in HL da memoria puntata da (0x40E6) UNK03
			RET						; Ritorna

			;
			; Routine 0x219A - INPUT/INPUT# 
			;
INPUT		CALL L2828				; Chiama la 0x2828 (L2828 IDTEST)									; Test for illegal direct
			LD A,(HL)				; Carica in A da memoria puntata da (HL)							; Get character after "INPUT"
			NOP     				;																	
			NOP     				;																	
			NOP     				;																	
			SUB 0x23				; Sottrae da A il valore 0x23 (carattere '#')
			LD (0x40A9),A			; Salva A in memoria puntata da (0x40A9)
			LD A,(HL)				; Carica in A da memoria puntata da (HL)							; Get character
			JR NZ,L21C9				; Se diverso da zero, passa a 0x21C9
			CALL VTPNOUT			; Chiama la 0x0293 (L0293 VTPNOUT)
			PUSH HL					; Salva HL nello stack
			LD B,0xFA				; Carica in B il valore 0xFA (numero byte da leggere)
			LD HL,(PBUFFER)			; Carica in HL da memoria puntata da (0x40A7) PBUFFER
L21B2		CALL VRDTAPE			; Chiama la 0x0235 (L0235 VRDTAPE)
			LD (HL),A				; Salva A in memoria puntata da (HL)
			INC HL					; Incrementa HL
			CP 0x0D					; Compara A con il valore 0x0D (carattere CR)
			JR Z,L21BD				; Se uguale, passa a 0x21BD
			DJNZ L21B2				; Decrementa B, se diverso da zero passa a 0x21B2
L21BD		DEC HL					; Decrementa HL
			LD (HL),0x00			; Salva il valore 0x00 in memoria puntata da (HL)
			CALL DELS18				; Chiama la 0x01F5 (L01F5 DELS18)
			LD HL,(PBUFFER)			; Carica in HL da memoria puntata da (0x40A7) PBUFFER
			DEC HL					; Decrementa HL																	
			JR L21EB				; Passa a 0x21EB (L21EB SVCOMMA)
			;
L21C9		LD BC,NOPMPT			; Carica in BC il valore 0x21DB (Puntatore a NOPMPT)
			PUSH BC					; Salva BC nello stack

			;
			; Routine 0x21CD
			;
L21CD		CP '"'					; Compara A con il valore 0x22 (carattere '"')					; Is there a prompt string?
			RET NZ					; Se diverso, ritorna												
			CALL L2866				; Chiama la 0x2866 (L2866 ?)																	
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)							; Check for ';' after prompt
			.BYTE ';'				; (carattere ';')
			PUSH HL					; Salva HL nello stack
			CALL PRSHL				; Chiama la 0x28AA (L28AA PRSHL)
			POP HL					; Recupera HL dallo stack
			RET						; Termina
			
			;
			; Routine 0x21DB - NOPMPT
			;
NOPMPT		PUSH HL					; Salva HL nello stack
			CALL VISPPIN			; Chiama la 0x1BB3 (L1BB3 VISPPIN)
			POP BC					; Recupera BC dallo STACK
			JP C,INPBRK				; Se CY=1, passa a 0x1DBE (L1DBE INPBRK)
			INC HL					; Incrementa HL
			LD A,(HL)				; Carica in A memoria puntata da (HL)
			OR A					; Esegue OR di A
			DEC HL					; Decrementa HL
			PUSH BC					; Salva BC nello stack
			JP Z,L1F04				; Se zero, passa a 0x1F04 (L1F04 NXTDTA)
									;  altrimenti continua con 0x21EB (L21EB SVCOMMA)

			;
			; Routine 0x21EB - SVCOMMA
			;
L21EB		LD (HL),0x2C			; Salva il valore 0x2C (carattere ',') in memoria puntata da (HL)	; Store comma as separator
			JR L21F4				; Passa alla 0x21F4 (L21F4 NXTITM)									; Get next item	

			; Routine 0x21EF - READ
			;
READ		PUSH HL					; Salva HL nello stack											; Save code string address
			LD HL,(NXTDAT)			; Carica in HL da memoria puntata da (0x40FF) NXTDAT			; Next DATA statement
			.BYTE 0xF6				; Esegue OR 0xAF  skip istruzione XOR A							; Flag "READ"
									;   continua con la 0x21F5 (L21F5)
									;
L21F4 		XOR A					; Azzera A														; Flag "INPUT"
L21F5		LD (READFG),A			; Salva A in memoria puntata da (0x40DE) READFG					; Save "READ"/"INPUT" flag
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)						; Get code str' , Save pointer
			JR L21FD				; Passa alla 0x21FD (L21FD GTVLUS)								; Get values

			;
			; Routine 0x21FB
			;
L21FB		RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)							; Check for comma between items
			.BYTE ','				; (carattere ',')

			;
			; Routine 0x21FD - GTVLUS  Legge valori con la READ
			;
L21FD		CALL GETVAR				; Chiama la 0x260D (L260D GETVAR)					; Get variable name
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)			; Save code str" , Get pointer
			PUSH DE					; Salva DE nello stack								; Save variable address
			LD A,(HL)				; Carica in A memoria puntata da (HL)				; Get next "INPUT"/"DATA" byte
			CP 0x2C					; Compara A con il valore 0x2C (carattere ',')		; Comma?
			JR Z,L222D				; Se zero, passa a 0x222D (L222D ?)					; Yes - Get another value
			LD A,(READFG)			; Carica in A memoria puntata da (0x40DE) READFG	; Is it READ?
			OR A					; Esegue OR di A
			JP NZ,L2296				; Se zero, passa alla 0x2296 (L2296 FDTLP)			; Yes - Find next DATA stmt
			LD A,(0x40A9)			; Carica in A memoria puntata da (0x40A9)			; More INPUT needed
			OR A					; Esegue OR di A									; Output character
			LD E,0x06				; Carica in E il valore 0x06 (codice Out Of DATA)	; Get INPUT with prompt
			JP Z,MSGERR				; Se zero, passa a 0x19A2 (L19A2 MSGERR)			; Variable address
			LD A,'?'				; Carica in A il valore 0x3F (carattere '?')		; Code string address
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)					; Break pressed
			CALL VISPPIN			; Chiama la 0x1BB3 (L1BB3 VISPPIN)					; Point to next DATA byte
			POP DE					; Recupera DE dallo stack							; Get byte
			POP BC					; Recupera BC dallo stack							; Is it zero (No input) ?
			JP C,INPBRK				; Se CY=1, passa a lla 0x1DBE (L1DBE INPBRK)		; Back space INPUT pointer
			INC HL					; Incrementa HL										; Save code string address
			LD A,(HL)				; Carica in A memoria puntata da (HL)				; Find end of buffer
			OR A					; Esegue OR di A									; Save variable address
			DEC HL					; Decrementa HL										; Check data type
			PUSH BC					; Salva BC nello stack								; Is it numeric?
			JP Z,L1F04				; NXTDTA											; Yes - Convert to binary
			PUSH DE					; Salva DE nello stack								; Get next character
L222D		NOP     				;													; Save input character
			NOP     				;													; Again
			NOP     				;													; Start of literal sting?
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			PUSH AF					; Salva AF nello stack
			JR NZ,L224D				; Se diverso da zero, passa a 0x224D
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			LD D,A					; Copia A in D
			LD B,A					; Copia A in B
			CP 0x22					; Compara A con il valore 0x22 (carattere '"')
			JR Z,L2240				; Se uguale, passa a 0x2240
			LD D,0x3A				; Carica in D il valore 0x3A (carattere ':')
			LD B,0x2C				; Carica in B il valore 0x2C (carattere ',')
			DEC HL					; Decrementa HL
L2240		CALL L2869				; Chiama la 0x2869 (L2869 ?)
L2243		POP AF					; Recurpera AF dallo stack
			EX DE,HL				; Scambia DE ed HL
			LD HL,0x225A			; Carica in HL il valore 0x225A (L225A ?)
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			PUSH DE					; Salva DE nello stack
			JP L1F33				; Passa alla 0x1F33 (L1F33 ?)
			;
L224D		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			POP AF					; Recurpera AF dallo stack
			PUSH AF					; Salva AF nello stack
			LD BC,L2243				; Carica in BC il valore 0x2243 (L2243 ?)
			PUSH BC					; Salva BC nello stack
			JP C,L0E6C				; PAND
			JP NC,L0E65				; Se CY=0, passa alla 0x0E65 (L0E65 ?)
			;
L225A		DEC HL					; Decrementa HL
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			JR Z,L2263				; Se zero, passa a 0x2263
			CP 0x2C					; Compara A con il valore 0x2C (carattere ',')
			JP NZ,L217F				; Se diverso da zero, passa a 0x217F (L217F ?)
L2263		EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			DEC HL					; Decrementa HL
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			JP NZ,L21FB				; Se diverso da zero, passa alla 0x21FB (L21FB ?)
			POP DE					; Recurpera DE dallo stack
			NOP						;
			NOP     				;
			NOP     				;
			NOP     				;
			NOP     				;
			LD A,(READFG)			; Carica in A memoria puntata da (0x40DE) READFG
			OR A					; Esegue OR di A
			EX DE,HL				; Scambia DE ed HL
			JP NZ,L1D96				; Se diverso da zero, passa a 0x1D96 (L1D96 ?)
			PUSH DE					; Salva DE nello stack
			NOP						;
			NOP						;
			NOP						;
			OR (HL)					; Esegue OR di A con memoria puntata da (HL) 
			LD HL,MEXIGN			; Carica in HL il valore 0x2286 (messaggio '?Extra ignored')
			CALL NZ,PRS				; Se diverso da zero, chiama la 0x28A7 (L28A7 PRS)
			POP HL					; Recupera HL dallo stack
			JP SETDEFVID			; Passa a 0x2169 (L2169 SETDEFVID)

			; Messaggio
MEXIGN		.TEXT '?Extra ignored', 0x0D, 0x00

			;
			; Routine 0x2296 - FDTLP
			;
L2296		CALL DATA				; Chiama la 0x1F05 (L1F05 DATA)					; Get next statement
			OR A					; Esegue OR di A								; End of line?
			JR NZ,L22AE				; Se diverso da zero, passa a 0x22AE			; No - See if DATA statement
			INC HL					; Incrementa HL
			LD A,(HL)				; Carica in A da memoria puntata da (HL)		; End of program?
			INC HL					; Incrementa HL
			OR (HL)					; Esegue OR di A con memoria puntata da (HL)	; 00 00 Ends program
			LD E,ECOD06				; Carica in E il valore 0x06 (Codice errore Out Of Data)
			JP Z,MSGERR				; Se zero, passa a 0x19A2 (L19A2 MSGERR)		; Yes - Out of DATA
			INC HL					; Incrementa HL
			LD E,(HL)				; Carica in E da memoria puntata da (HL)		; LSB of line number
			INC HL					; Incrementa HL
			LD D,(HL)				; Carica in D da memoria puntata da (HL)		; MSB of line number
			EX DE,HL				; Scambia DE ed HL
			LD (DATLIN),HL			; Salva HL in memoria puntata da (0x40DA) DATLIN	; Set line of current DATA item
			EX DE,HL				; Scambia DE ed HL
L22AE		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			CP TKDATA				; Compara A con il valore 0x88 (Token DATA)
			JR NZ,L2296				; Se diverso, passa a 0x2296
			JP L222D				; Passa a 0x222D (L222D ?)						; Found - Convert input

			;
			; Routine 0x22B6 - NEXT
			;
NEXT		LD DE,0x0000			; Azzera DE, default nessun indice						; In case no index given
NEXTLP		CALL NZ,GETVAR			; Se diverso da zero, chiama la 0x260D (L260D GETVAR), ottiene indirizzo indice, se indicato	; Get index address
			LD (PCODE2RUN),HL		; Salva HL in memoria puntata da (0x40DF) PCODE2RUN		; Save code string address
			CALL LKFORGOSUB			; Chiama la 0x1936 (L1936 LKFORGOSUB), cerca blocchi FOR attivi		; Look for "FOR" block
			JP NZ,NFERR				; Se diverso da zero, passa a 0x199D (L199D NFERR), nessun blocco attivo, errore	; No "FOR" - ?NF Error
			LD SP,HL				; Carica in SP il valore di HL							; Clear nested loops
			LD (SPTMP),HL			; Salva HL in memoria puntata da (0x40E8) SPTMP			
			PUSH DE					; Salva DE nello stack, indirizzo indice nello stack	; Save index address
			LD A,(HL)				; Carica in A da memoria puntata da (HL), segno dello STEP		; Get sign of STEP
			INC HL					; Incrementa HL
			PUSH AF					; Salva AF nello stack, segno STEP nello stack			; Save sign of STEP
			PUSH DE					; Salva AF nello stack, indirizzo indice nello stack	; Save index address
			LD A,(HL)				; Carica in A da memoria puntata da (HL)				
			INC HL					; Incrementa HL																
			OR A					; Esegue OR di A										
			JP M,L22EA				; Se negativo, passa a 0x22EA 														
			CALL PHL2BCDEFP			; Chiama la 0x09B1 (L09B1 PHL2BCDEFP), carica variabile indice in FPREG		; Move index value to FPREG
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)				; Save address of TO value
			PUSH HL					; Salva HL nello stack									; Save address of index
			CALL ADDPHL				; Chiama la 0x070B (L070B ADDPHL), somma STEP al valore indice	; Add STEP to index value
			POP HL					; Recupera HL dallo stack								; Restore address of index
			CALL CPYFPREGHL			; Chiama la 0x09CB (L09CB CPYFPREGHL), salva FPREG nella variabile indice		; Move value to index variable
			POP HL					; Recupera HL dallo stack								; Restore address of TO value
			CALL PHL2BCDE			; Chiama la 0x09C2 (L09C2 PHL2BCDE), converte valore TO in BCDE	; Move TO value to BCDE
			PUSH HL					; Salva HL nello stack									; Save address of line of FOR
			CALL CMPNUM				; Chiama la 0x0A0C (L0A0C CMPNUM), compara indice con valore TO		; Compare index with TO value
			JR L2313				; Passa a 0x2313
			;
L22EA		INC HL					; Incrementa HL
			INC HL					; Incrementa HL
			INC HL					; Incrementa HL
			INC HL					; Incrementa HL
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			INC HL					; Incrementa HL
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			LD E,(HL)				; Carica in E da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD D,(HL)				; Carica in D da memoria puntata da (HL)
			PUSH HL					; Salva HL nello stack
			LD L,C					; Copia C in L
			LD H,B					; Copia B in H
			CALL L0BD2				; Chiama la 0x0BD2 (L0BD2 ?)
			LD A,(TYPE)				; Carica in C da memoria puntata da (0x40AF) TYPE
			CP 0x04					; Compara A con il valore 0x04 (single)
			JP Z,OVERR				; Passa a 0x07B2 (L07B2 OVERR)
			EX DE,HL				; Scambia DE ed HL
			POP HL					; Recupera HL dallo stack
			LD (HL),D				; Salva D in memoria puntata da (HL)
			DEC HL					; Decrementa HL
			LD (HL),E				; Salva E in memoria puntata da (HL)
			POP HL					; Recupera HL dallo stack
			PUSH DE					; Recupera DE dallo stack
			LD E,(HL)				; Carica in E da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD D,(HL)				; Carica in D da memoria puntata da (HL)
			INC HL					; Incrementa HL
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			CALL L0A39				; Chiama la 0x0A39 (L0A39 ?)
									; Comparazione indice e TO
L2313		POP HL					; Recupera HL dallo stack
			POP BC					; Recupera BC dallo stack
			SUB B					; Sottrae B da A
			CALL PHL2BCDE			; Chiama la 0x09C2 (L09C2 PHL2BCDE)
			JR Z,L2324				; Se zero, passa a 0x2324
			EX DE,HL				; Scambia DE ed HL
			LD (LINEAT),HL			; Salva HL in memoria puntata da (0x40A2) LINEAT
			LD L,C					; Copia C in L
			LD H,B					; Copia B in H
			JP L1D1A				; Passa a 0x1D1A 
			;
L2324		LD SP,HL				; Copia HL in SP
			LD (SPTMP),HL			; Salva HL in memoria puntata da (0x40E8) SPTMP
			LD HL,(PCODE2RUN)		; Carica in HL da memoria puntata da (0x40DF) PCODE2RUN
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CP ','					; Compara A con il valore 0x2C (carattere ',')
			JP NZ,RUNCNT			; Se diverso, passa a 0x1D1E (L1D1E RUNCNT)
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			CALL NEXTLP				; Chiama la 0x22B9 (L22B9 NEXTLP)
									;   continua con la 0x2335 (L2335 OPNPAR)

			; 
			; Routine 0x2335 - OPNPAR
			;
L2335		RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)							; Make sure "(" follows					
			.BYTE '('				; (carattere '(')
									;   continua con la 0x2337 (L2337 EVAL)

			;
			; Routine 0x2337 - EVAL
			;	
EVAL		DEC HL					; Decrementa HL												; Evaluate expression & save
									;  continua con la 0x2338 (L2338 EVAL1)

			;
			; Routine 0x2338 - EVAL1
			;	
L2338		LD D,0x00				; Azzera D													; Precedence value
L233A		PUSH DE					; Salva DE nello stack										; Save precedence
			LD C,0x01				; Carica in C il valore 0x01, test per 1 livello di stack	; Stack level 1
			CALL CHKSTK				; Chiama la 0x1963 (L1963 CHKSTK)							; Check for 1 level of stack
			CALL L249F				; Chiama la 0x249F (L249F OPRND)							; Get next expression value
			; EVAL2
			LD (NXTOPR),HL			; Salva HL in memoria puntata da (0x40F3) NXTOPR			; Save address of next operator NXTOPR
			; EVAL3
L2346		LD HL,(NXTOPR)			; Carica in HL memoria puntata da (0x40F3) NXTOPR			; Restore address of next opr NXTOPR
			POP BC					; Recupera BC dallo stack									; Precedence value and operator
			LD A,(HL)				; Carica in A memoria puntata da (HL)						; Get next operator / function
			LD D,0x00				; Azzera D													; Clear Last relation
			; RLTLP
L234D		SUB TKGT				; Sottrae da A il valore 0xD4 (Token >)						; ">" Token
			JR C,L2364				; Se CY=1, passa a 0x2364									; + - * / ^ AND OR - Test it
			CP 0x03					; Compara A con il valore 0x03								; < = >
			JR NC,L2364				; Se CY=0, passa a 0x2364									; Function - Call it
			CP 0x01					; Compara A con il valore 0x01								; "="
			RLA    					; Ruota A a sinistra di 1 bit								; <- Test for legal
			XOR D					; Azzera D													; <- combinations of < = >
			CP D					; Compara A con D											; <- by combining last token				
			LD D,A					; Copia A in D												; <- with current one
			JP C,SNERR				; Se CY=1, passa a 0x1997 (L1997 SNERR)						; Error if "<<' '==" or ">>"
			LD (CUROPR),HL			; Salva HL in memoria puntata da (0x40D8) CUROPR			; Save address of current token 
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)	; Get next character
			JR L234D				; Passa a 0x234D (L234D RLTLP)								; Treat the two as one
			; FOPRND
L2364		LD A,D					; Copia D in A
			OR A					; Esegue OR di A
			JP NZ,L23EC				; Se diverso da zero, passa a 0x23EC
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			LD (CUROPR),HL			; Salva HL in memoria puntata da (0x40D8) CUROPR
			SUB TKPLUS				; Sottrae da A il valore 0xCD (Token +)
			RET C					; Se CY=1, ritorna
			CP 0x07					; Compara A con il valore 0x07 (Token +-*/^ AND OR)
			RET NC					; Se CY=0, ritorna
			LD E,A					; Copia A in E
			LD A,(TYPE)				; Carica in A da memoria puntata da (0x40AF) TYPE
			SUB 0x03				; Sottrae da A il valore 0x03 (Test stringa)
			OR E					; Esegue OR di A con E
			JP Z,L298F				; Se zero, passa alla 0x298F (L298F ?)
			LD HL,PRITAB			; Carica in HL il valore 0x189A (puntatore a PRITAB)
			ADD HL,DE				; Somma DE ad HL (punta alla precedenza dell'operatore corrente)
			LD A,B					; Copia B in A
			LD D,(HL)				; Carica in D da memoria puntata da (HL)
			CP D					; Compara A con D
			RET NC					; Se CY=0, ritorna
			PUSH BC					; Salva BC nello stack
			LD BC,0x2346			; Carica in BC il valore 0x2346
			PUSH BC					; Salva BC nello stack
			LD A,D					; Copia D in A
			CP 0x7F					; Compara A con il valore 0x7F
			JP Z,L23D4				; Se uguale, passa a 0x23D4
			CP 0x51					; Compara A con il valore 0x51
			JP C,L23E1				; Se CY=1, passa a 0x23E1
L2395		LD HL,FPREG				; Carica in HL il valore 0x4121 (puntatore a FPREG)
			OR A					; Esegue OR di A
			LD A,(TYPE)				; Carica in A da memoria puntata da (0x40AF) TYPE
			DEC A					; Decrementa A
			DEC A					; Decrementa A
			DEC A					; Decrementa A
			JP Z,TMERR				; Se zero, passa a 0x0AF6 (L0AF6 TMERR) (tipo stringa)
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			PUSH BC					; Salva BC nello stack
			JP M,L23C5				; Se negativo, passa a 0x23C5
			INC HL					; Incrementa HL
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			PUSH BC					; Salva BC nello stack
			PUSH AF					; Salva AF nello stack
			OR A					; Esegue OR di A
			JP PO,L23C4				; Se po, passa a 0x23C4
			POP AF					; Recupera AF dallo stack
			INC HL					; Incrementa HL
			JR C,L23BA				; Se CY=1, passa a 0x23BA
			LD HL,TDBL1				; Carica in HL il valore 0x411D (puntatore a TDBL1)
L23BA		LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			INC HL					; Incrementa HL
			PUSH BC					; Salva BC nello stack
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			PUSH BC					; Salva BC nello stack
			.BYTE 0x06				; Esegue LD B,0xF1	slip istruzione POP AF
									;  continua con 0x23C5 (L23C5)
L23C4		POP AF					; Recupera AF dallo stack
L23C5		ADD A,0x03				; Somma ad A il valore 0x03
			LD C,E					; Copia E in C
			LD B,A					; Copia A in B
			PUSH BC					; Salva BC nello stack
			LD BC,0x2406			; Carica in BC il valore 0x2406 (L2406 ?)
L23CD		PUSH BC					; Salva BC nello stack
			LD HL,(CUROPR)			; Carica in HL da memoria puntata da (0x40D8) CUROPR
			JP L233A				; Passa a 0x233A
			;
L23D4		CALL CSNG				; Chiama la 0x0AB1 (L0AB1 CSNG)
			CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)
			LD BC,L13F2				; Carica in BC il valore 0x13F2 (puntatore a L13F2)
			LD D,0x7F				; Carica in D il valore 0x7F
			JR L23CD				; Passa a 0x23CD
			;
L23E1		PUSH DE					; Salva DE nello stack
			CALL CINT				; Chiama la 0x0A7F (L0A7F CINT)
			POP DE					; Recupera DE dallo stack
			PUSH HL					; Salva HL nello stack
			LD BC,0x25E9			; Carica in BC il valore 0x25E9 (L25E9 ?)
			JR L23CD				; Passa a 0x23CD
			;
L23EC		LD A,B					; Copia B in A
			CP 0x64					; Compara A con il valore 0x64 FLAGFOR??
			RET NC					; Se CY=0, ritorna
			PUSH BC					; Salva BC nello stack
			PUSH DE					; Salva DE nello stack
			LD DE,0x6404			; Carica in DE il valore 0x6404
			LD HL,CMPRES			; Carica in HL il valore 0x25B8 (L25B8 CMPRES)
			PUSH HL					; Salva HL nello stack
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			JP NZ,L2395				; Se diverso da zero, passa a 0x2395
			LD HL,(FPREG)			; Carica in HL da memoria puntata da (0x4121) FPREG
			PUSH HL					; Salva HL nello stack
			LD BC,CMPLOG			; Carica in BC il valore 0x258C (puntatore alla CMPLOG)
			JR L23CD				; Passa a 0x23CD
			;
L2406		POP BC					; Recupera BC dallo stack
			LD A,C					; Copia C in A
			LD (DATFLG),A			; Salva A in memoria puntata da (0x40B0) DATFLG				; Set literal flag	
			LD A,B					; Copia B in A
			CP 0x08					; Compara A con il valore 0x08 
			JR Z,L2438				; Se uguale, passa alla 0x2438 (L2438 ?)
			LD A,(TYPE)				; Carica in A da memoria puntata da (0x40AF) TYPE
			CP 0x08					; Compara A con il valore 0x08 (double)
			JP Z,L2460				; Se uguale, passa alla 0x2460
			LD D,A					; Copia A in D
			LD A,B					; Copia B in A
			CP 0x04					; Compara A con il valore 0x04 (single)
			JP Z,L2472				; Se uguale, passa alla 0x2472
			LD A,D					; Copia D in A
			CP 0x03					; Compara A con il valore 0x03 (stringa)
			.BYTE 0xCA				; Esegue JP Z,TMERR [0x0AF6]  skip istruzione OR 0x0A
									;   continua con la 0x2425 (L2425)
L2423		OR 0x0A					; Esegue OR di A con il valore 0x0A
L2425		JP NC,L247C				; Se CY=0, passa alla 0x247C (L247C ?)
			LD HL,ERRMSGVEC-0x0A	; Carica in HL il valore 0x18BF (puntatore a ERRMSGVEC-0x0A)
			LD B,0x00				; Azzera B
			ADD HL,BC				; Somma BC ad HL
			ADD HL,BC				; Somma BC ad HL
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			POP DE					; Recupera DE dallo stack
			LD HL,(FPREG)			; Carica in HL da memoria puntata da (0x4121) FPREG
			PUSH BC					; Salva BC nello stack
			RET						; Ritorna

			;
			; Routine 0x2438
			;
L2438		CALL CDBL				; Chiama la 0x0ADB (L0ADB CDBL)
			CALL L09FC				; Chiama la 0x09FC (L09FC MVFPSTMP)
			POP HL					; Recupera HL dallo stack
			LD (TDBL2),HL			; Salva HL in memoria puntata da (0x411F) TDBL2
			POP HL					; Recupera HL dallo stack
			LD (TDBL1),HL			; Salva HL in memoria puntata da (0x411D) TDBL1
L2446		POP BC					; Recupera BC dallo stack
			POP DE					; Recupera DE dallo stack
			CALL BCDE2FPR			; Chiama la 0x09B4 (L09B4 BCDE2FPR)
L244B		CALL CDBL				; Chiama la 0x0ADB (L0ADB CDBL)
			LD HL,TABOPER			; Carica in HL il valore 0x18AB (puntatore a TABOPER)
L2451		LD A,(DATFLG)			; Carica in A da memoria puntata da (0x40B0)
			RLCA					; Ruota A a sinistra di 1 bit
			PUSH BC					; Salva BC nello stack
			LD C,A					; Copia A in C
			LD B,0x00				; Azzera B
			ADD HL,BC				; Somma BC ad HL
			POP BC					; Recupera BC dallo stack
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD H,(HL)				; Carica in H da memoria puntata da (HL)
			LD L,A					; Copia A in L
			JP (HL)					; Passa a indirizzo puntato da (HL)
			;
L2460		PUSH BC					; Salva BC nello stack
			CALL L09FC				; Chiama la 0x09FC (L09FC MVFPSTMP)
			POP AF					; Recupera AF dallo stack
			LD (TYPE),A				; Salva A in memoria puntata da (0x40AF) TYPE
			CP 0x04					; Compara A con il valore 0x04
			JR Z,L2446				; Se uguale, passa a 0x2446
			POP HL					; Recupera HL dallo stack
			LD (FPREG),HL			; Salva HL in memoria puntata da (0x4121)
			JR L244B				; Passa a 0x244B

			;
			; Routine 0x2472
			;
L2472		CALL CSNG				; Chiama la 0x0AB1 (L0AB1 CSNG)
			POP BC					; Recupera BC dallo stack 
			POP DE					; Recupera DE dallo stack 
L2477		LD HL,0x18B5			; Carica in HL il valore 0x18B5
			JR L2451				; Passa a 0x2451

			;
			; Routine 0x247C
			;
L247C		POP HL					; Recupera HL dallo stack
			CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)
			CALL L0ACF				; Chiama la 0x0ACF (L0ACF ?)
			CALL FPR2BCDE			; Chiama la 0x09BF (L09BF FPR2BCDE)
			POP HL					; Recupera HL dallo stack
			LD (FPREGMSB),HL		; Salva HL in memoria puntata da (0x4123) FPREGMSB
			POP HL					; Recupera HL dallo stack
			LD (FPREG),HL			; Salva HL in memoria puntata da (0x4121) FPREG
			JR L2477				; Passa a 0x2477

			;
			; Routine 0x2490
			;
L2490		PUSH HL					; Salva HL nello stack
			EX DE,HL				; Scambia DE ed HL
			CALL L0ACF				; Chiama la 0x0ACF (L0ACF ?)
			POP HL					; Recupera HL dallo stack
			CALL FPRONSTK			; Chiama la 0x09A4 (L09A4 FPRONSTK)
			CALL L0ACF				; Chiama la 0x0ACF (L0ACF ?)
			JP DIV					; Passa alla 0x08A0 (L08A0 DIV)

			;
			; Routine 0x249F - OPRND  Gestisce nuovo operando in una espressione
			;
L249F 		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			LD E,ECOD28				; Carica in E il valore 0x28 (codice errore Missing Operand)
			JP Z,MSGERR				; Se zero, passa a 0x19A2 (L19A2 MSGERR)
			JP C,L0E6C				; Se CY=1, passa alla 0x0E6C (L0E6C PAND)
			CALL CHKLTR				; Chiama la 0x1E3D (L1E3D CHKLTR)
			JP NC,CONVAR			; Se CY=0, passa a 0x2540 (L2540 CONVAR)
			CP TKPLUS				; Compara A con il valore 0xCD (Token +)
			JR Z,L249F				; Se uguale, passa a 0x249F
			CP 0x2E					; Compara A con il valore 0x2E (carattere '.')
			JP Z,L0E6C				; Se uguale, passa a 0x0E6C (L0E6C PAND)
			CP TKMINUS				; Compara A con il valore 0xCE (Token -)
			JP Z,MINUS				; Se uguale, passa a 0x2532 (L2532 MINUS)
			CP '"'					; Compara A con il valore 0x22 (carattere '"')
			JP Z,L2866				; Se uguale, passa a 0x2866 (L866 ?)
			CP TKNOT				; Compara A con il valore 0xCB (Token NOT)
			JP Z,NOT				; Se uguale, passa a 0x25C4 (L25C4 NOT)
			CP '&'					; Compara A con il valore 0x26 (carattere '&')
			JP Z,HCONV				; Se uguale, passa a 0x0583 (L0583 HCONV)
			CP TKERR				; Compara A con il valore 0xC3 (Token ERR)
			JR NZ,L24D9				; Se diverso passa a 0x24D9 (L24D9)

			;
			; Routinr 0x24CF - ERR (Token 0xC3)
			;
ERR			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			LD A,(CURERR)			; Carica in A memoria puntata da (0x409A) CURERR
			PUSH HL					; Salva HL nello stack
			CALL MVAU2FPR			; Chiama la 0x27F8 (L27F8 MVAU2FPR)
			POP HL					; Recupera HL dallo stack
			RET   					; Ritorna
			;
L24D9 		CP 0xC2					; Compara A con il valore 0xC2 (ERL)
			JR NZ,L24E7				; Se diverso passa a 0x24E7 (L24E7)

			;
			; Routine 0x24DD - ERL (Token 0xC2)
			;
ERL			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			PUSH HL					; Salva HL nello stack
			LD HL,(CURERL)			; Carica in HL da memoria puntata da (0x40EA) CURERL
			CALL L0C66				; Chiama la 0x0C66 (L0C66 ?)
			POP HL					; Recupera HL dallo stack
			RET     				; Ritorna
			;
L24E7 		CP 0xC0					; Compara A con il valore 0xC0 (VARPTR)
			JR NZ,L24FF				; Se diverso passa a 0x24FF (L24FF)

			;
			; Routine 0x24EB - VARPTR (Token 0xC0)
			;
VARPTR		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE '('				; (carattere '(')
			CALL GETVAR				; Chiama la 0x260D (L260D GETVAR)
L24F1		RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ')'				; (carattere ')')
			PUSH HL					; Salva HL nello stack
			EX DE,HL				; Scambia DE ed HL
			LD A,H					; Copia H in A
			OR L					; Esegue OR di A con L
			JP Z,IFERR				; Se zero, passa alla 0x1E4A (L1E4A IFERR)
			CALL MVHL2FPR			; Chiama la 0x0A9A (L0A9A MVHL2FPR) 
			POP HL					; Recupera HL dallo stack
			RET  					; Ritorna   
			;
L24FF 		CP TKUSR				; Compara A con il valore 0xC1 (Token USR)
			JP Z,USR				; Se uguale, passa a 0x27FE (L27FE USR)
			;
			CP TKINSTR				; Compara A con il valore 0xC5 (Token INSTR)
			JP Z,INSTR				; Se uguale, passa a 0x33DD (L33DD INSTR)
			;
			CP TKMEM				; Compara A con il valore 0xC8 (Token MEM)
			JP Z,MEM				; Se uguale, passa a 0x27C9 (L27C9 MEM)
			;
			CP TKTIME				; Compara A con il valore 0xC7 (Token TIME$) (non implementato)
			JP Z,SNERR2				; Se uguale, passa a 0x012D (L012D SNERR2) 
			;
			CP TKPOINT				; Compara A con il valore 0xC6 (Token POINT)
			JP Z,POINT				; Se uguale, passa a 0x0132 (L0132 POINT)
			;
			CP TKINKEY				; Compara A con il valore 0xC9 (Token INKEY$)
			JP Z,INKEY				; Se uguale, passa a 0x019D (L019D INKEY$)
			;
			CP TKSTRING				; Compara A con il valore 0xC4 (Token STRING$)
			JP Z,STRING				; Se uguale, passa a 0x2A2F (L2A2F STRING$)
			;
			CP TKFN					; Compara A con il valore 0xBE (Token FN)
			JP Z,FN					; Se uguale, passa a 0x32AC (L32AC FN)
			;
			SUB 0xD7				; Sottrae da A il valore 0xD7
			JP NC,FNOFST			; Se CY=0, passa a 0x254E (L254E FNOFST)
L252C		CALL L2335				; Chiama la 0x2335 (L2335 ?)
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ')'				; (carattere ')')
			RET     				; Ritorna

			;
			; Routine 0x2532 - MINUS
			;
MINUS		LD D,0x7D				; Carica in D il valore 0x7D							; '-' precedence
			CALL L233A				; Chiama la 0x233A (L233A ?)							; Evaluate until precedence break
			LD HL,(NXTOPR)			; Carica in HL da memoria puntata da (0x40F3) NXTOPR	; Get next operator address NXTOPR
			PUSH HL					; Salva HL nello stack									; Save next operator address
			CALL L097B				; Chiama la 0x097B (L097B INVSGN)						; Negate value
									;  continua con la 0x253E (L253E POPHL)

			;
			; Routine 0x253E - POPHL
			;
POPHL		POP HL					; Recupera HL dallo stack								; Restore next operator address
			RET        				; Ritorna

			;
			; Routine 0x2540 - CONVAR
			;
CONVAR 		CALL GETVAR				; Chiama la 0x260D (L260D GETVAR)
									;   continua con la 0x2543 (L2543 FRMEVL)

			;
			; Routine 0x2543 - FRMEVL
			;
FRMEVL		PUSH HL					; Salva HL nello stack
			EX DE,HL				; Scambia DE ed HL
			LD (FPREG),HL			; Salva HL in memoria puntata da (0x4121)
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			CALL NZ,L09F7			; Se non zero, chiama la 0x09F7 (L09F7 ?)
			POP HL					; Recupera HL dallo stack
			RET     				; Ritorna

			;
			; Routine 0x254E - FNOFST  Esegue funzione
			;
FNOFST 		LD B,0X00				; Azzera B
			RLCA    				; Ruota a sinistra A di 1 bit
			LD C,A					; Copia A in C
			PUSH BC					; Salva BC nello stack
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			LD A,C					; Copia C in A
			CP 'A'					; Compara A con il valore 0x41 (carattere 'A' ?)
			JR C,FNVAL				; Se CY=1, passa a 0x256F (L256F FNVAL)
			CALL L2335				; Chiama la 0x2335 (L2335 ?)
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','				; (carattere ',')
			CALL TSTSTR				; Chiama la 0x0AF4 (L0AF4 TSTSTR)
			EX DE,HL				; Scambia DE ed HL
			LD HL,(FPREG)			; Carica in HL memoria puntata da (0x4121)
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			PUSH HL					; Salva HL nello stack
			EX DE,HL				; Scambia DE ed HL
			CALL GETBYT				; Chiama la 0x2B1C (L2B1C GETBYT)
			EX DE,HL				; Scambia DE ed HL
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			JR GOFUNC				; Passa a 0x2583 (L2583 GOFUNC)
			
			;
			; Routine 0x256F - FNVAL
			;
FNVAL 		CALL L252C				; Chiama la 0x252C (L252C ?)
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			LD A,L					; Copia L in A
			CP 0x0C					; Compara A con il valore 0x0C
			JR C,L257F				; Se CY=1, passa a 0x257F
			CP 0x1B					; Compara A con il valore 0x1B
			PUSH HL					; Salva HL nello stack
			CALL C,CSNG				; Se CY=1, chiama la 0x0AB1 (L0AB1 CSNG)
			POP HL					; Recupera HL dallo stack
L257F		LD DE,POPHL				; Carica in DE il valore 0x253E (L253E POPHL)
			PUSH DE					; Salva DE nello stack
									;   continua con la 0x2583 (L2583 GOFUNC)
			
			;
			; Routine 0x2583 - GOFUNC
			;
GOFUNC 		LD BC,TABFUNC			; Carica in BC il valore 0x1608 (Tabella entry-point funzioni)
									;  continua con la 0x2586 (L2586 EXECFNOP)

			;
			; Routine 0x2586 - EXECFNOP
			;   Input: HL 
			;		   BC
			;
EXECFNOP	ADD HL,BC				; Somma BC ad HL
			LD C,(HL)				; Carica in C memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD H,(HL)				; Carica in H memoria puntata da (HL)
			LD L,C					; Copia C in L
			JP (HL)					; Passa a indirizzo puntato da (HL)

			;
			; Routine 0x258C - CMPLOG
			;		
CMPLOG		CALL L29D7				; Chiama la 0x29D7 (L29D7 GETSTR)
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			POP DE					; Recupera DE dallo stack
			PUSH BC					; Salva BC nello stack
			PUSH AF					; Salva AF nello stack
			CALL L29DE				; Chiama la 0x29DE (L29DE GSTRDE)
			POP DE					; Recupera DE dallo stack
			LD E,(HL)				; Carica in E da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			POP HL					; Recupera HL dallo stack
									;   continua con la 0x25A1 (L25A1 CMPSTR)

			;
			; Routine 0x25A1 - CMPSTR
			;
CMPSTR		LD A,E					; Copia E in A
			OR D					; Esegue OR di A con D
			RET Z					; Se zero, ritorna
			LD A,D					; Copia D in A
			SUB 0x01				; Sottrae 1 ad A
			RET C					; Se CY=1, ritorna
			XOR A					; Azzera A
			CP E					; Compara A con E
			INC A					; Incrementa A
			RET NC					; Se CY=0, ritorna
			DEC D					; Decrementa D
			DEC E					; Decrementa E
			LD A,(BC)				; Carica in A da memoria puntata da (BC)
			CP (HL)					; Compara A con memoria puntata da (HL)
			INC HL					; Incrementa HL
			INC BC					; Incrementa BC
			JR Z,CMPSTR				; Se zero, passa a 0x25A1 (L25A1 CMPSTR)
			CCF						; Complementa il CY
			JP FLGDIF				; Passa alla 0x0960 (L0960 FLGDIF)

			;
			; Routine 0x25B8 - CMPRES
			;
CMPRES		INC A					; Incrementa A
			ADC A,A					; Somma A ad A
			POP BC					; Recupera BC dallo stack
			AND B					; Esegue AND di A con B
			ADD A,0xFF				; Somma ad A il valore 0xFF (-1)
			SBC A,A					; Sottrae A da A
			CALL MVAS2FPR			; Chiama la 0x098D (L098D MVAS2FPR)
			JR L25D6				; Pasaa alla 0x25D6 (L25D6 ?)

			;
			; Routine 0x25C4 - NOT  Valuta la NOT
			;
NOT			LD D,0x5A				; Carica in D il valore 0x5A				; Precedence value for "NOT"
			CALL L233A				; Chiama la 0x233A (L233A ?)                ; Eval until precedence break
			CALL CINT				; Chiama la 0x0A7F (L0A7F CINT)             ; Get integer -32768 +32767
			LD A,L					; Copia L in A                              ; Get LSB
			CPL     				; Complementa A                             ; Invert LSB
			LD L,A					; Copia A in L                              ; Save "NOT" of LSB
			LD A,H					; Copia H in A                              ; Get MSB
			CPL     				; Complementa A                             ; Invert MSB
			LD H,A					; Copia A in H                              ; Save "NOT" of MSB
			LD (FPREG),HL			; Salva HL in memoria puntata da (0x4121)   ; Save "NOT" of HL
			POP BC					; Recupera BC dallo stack                   ; Clean up stack
L25D6		JP L2346				; Passa alla 0x2346 (L2346 ?)               ; Continue evaluation

			;
			; Routine 0x25D9 - GETTYPE Restituisce tipo dato (da RST 0x20)
			;   Output: Se CY=1 >> Z=1 String, Z=0 Numeric, N=0 Sng/Dbl, N=1 Int
			;		    Se CY=0 >> Z=1 String, Z=0 Numeric, N=0 Sng/Dbl, N=1 Int
			;
GETTYPE		LD A,(TYPE)				; Carica in A da memoria puntata da (0x40AF) TYPE
			CP 0x08					; Compara A con il valore 0x08 (double)
			JR NC,L25E5				; Se CY=0, passa a 0x25E5
			SUB 0x03				; Sottrae da A il valore 0x03 (stringa)
			OR A					; Esegue OR di A
			SCF     				; Imposta CY=1
			RET  					; Ritorna 
L25E5		SUB 0x03				; Sottrae da A il valore 0x03 (stringa)
			OR A					; Esegue OR di A
			RET     				; Ritorna ()

			;
			; Routine 0x25E9
			;
L25E9		PUSH BC					; Salva BC nello stack
			CALL CINT				; Chiama la 0x0A7F (L0A7F CINT)
			POP AF					; Recuper AF dallo stack
			POP DE					; Recuper DE dallo stack
			LD BC,0x27FA			; Carica in BC il valore 0x27FA
			PUSH BC					; Salva BC nello stack
			CP 0x46					; Compara A con il valore 0x46 (carattere 'F' ?)
			JR NZ,L25FD				; Se diverso, passa a 0x25FD
			LD A,E					; Copia E in A
			OR L					; Esegue OR di A con L
			LD L,A					; Copia A in L
			LD A,H					; Copia H in A
			OR D					; Esegue OR di A con D
			RET						; Ritorna     
			;
L25FD 		LD A,E					; Copia E in A
			AND L					; Esegue AND di A con L
			LD L,A					; Copia A in L
			LD A,H					; Copia H in A
			AND D					; Esegue AND di A con D
			RET     				; Ritorna

			; 
			; Routine 0x2603 - DIMRET
			;
DIMRET		DEC HL					; Decrementa HL												; DEC 'cos GETCHR INCs
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)							; Get next character
			RET Z					; Se zero, ritorna											; End of DIM statement
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)						; Make sure ',' follows
			.BYTE ','				; (carattere ',')						

			; 
			; Routine 0x2608 - DIM
			;
DIM			LD BC,DIMRET			; Carica in BC il valore 0x2603 (puntatore a DIMRET)		; Return to "DIMRET"
			PUSH BC					; Salva BC nello stack										; Save on stack
									;  continua con la 0x260C (L260C MAKVAR)

			;
			; Routine 0x260C - MAKVAR  Crea variabile
			;   Output: DE indirizzo variabile
			;
MAKVAR		.BYTE 0xF6				; Esegue OR 0xAF   skip istruzione XOR A					; Flag "Create" variable
									;   continua con la 0x260E (L260E) 
		
			;
			; Routine 0x260D - GETVAR  Ottiene tipo e lunghezza variabile
			;   Input:  HL puntatore a prima lettera variabile
			;   Output: DE indirizzo variabile
			;
GETVAR		XOR A					; Azzera A													; Flag "Locate" variable
L260E		LD (LCRFLG),A			; Azzera memoria puntata da (0x40AE) LCRFLG					; Set locate / create flag
			LD B,(HL)				; Carica in B da memoria puntata da (HL)					; Get First byte of name
L2612 		CALL CHKLTR				; Chiama la 0x1E3D (L1E3D CHKLTR)							; See if a letter
			JP C,SNERR				; Se CY=1, non è una lettera, passa a 0x1997 (L1997 SNERR)	; ?SN Error if not a letter
			XOR A					; Azzera A
			LD C,A					; Azzera C													; Clear second byte of name
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)							; Get next character
			JR C,L2622				; Se CY=1, numerico, passa a 0x2622							; Numeric - Save in name
			CALL CHKLTR				; Chiama la 0x1E3D (L1E3D CHKLTR)							; See if a letter 
			JR C,L262B				; Se CY=1, numerico, passa a 0x262B							; Not a letter - Check type
L2622		LD C,A					; Copia A in C												; Save second byte of name	
L2623		RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)							; Get next character
			JR C,L2623				; Se CY=1, numerico, passa a 0x2623							; Numeric - Get another
			CALL CHKLTR				; Chiama la 0x1E3D (L1E3D CHKLTR)							; See if a letter
			JR NC,L2623				; Se CY=0, è una lettera, passa a 0x2623											
L262B		LD DE,0x2652			; Carica in DE il valore 0x2652 (punta a L2652 per rientro)
			PUSH DE					; Salva DE nello stack
			LD D,0x02				; Carica in D il valore 0x02 (2 byte per variabile intera)
			CP '%'					; Compara A con il valore 0x25 (carattere '%')
			RET Z					; Se uguale, ritorna (a L2652)
			INC D					; Incrementa D (3 byte per variabile stringa)
			CP '$'					; Compara A con il valore 0x24 (carattere '$')
			RET Z					; Se uguale, ritorna (a L2652)
			INC D					; Incrementa D (4 byte per variabile single)
			CP '!'					; Compara A con il valore 0x21 (carattere '!')
			RET Z					; Se uguale, ritorna (a L2652)
			LD D,0x08				; Carica in D il valore 0x08 (8 byte per variabile double)
			CP '#'					; Compara A con il valore 0x23 (carattere '#')
			RET Z					; Se uguale, ritorna  (a L2652)
			LD A,B					; Copia B in A
			SUB 'A'					; Sottrae da A il valore 0x41 (lettera 'A')
			AND 0x7F				; Esegue AND di A con il valore 0x7F
			LD E,A					; Copia A in E
			LD D,0x00				; Azzera D
			PUSH HL					; Salva HL nello stack
			LD HL,DEFTVAR			; Carica in HL il valore 0x4101 (puntatore a tabella tipo variabili DEFTVAR)
			ADD HL,DE				; Somma DE ad HL
			LD D,(HL)				; Carica in D da memoria puntata da (HL), tipo variabile
			POP HL					; Recupera HL dallo stack
			DEC HL					; Decrementa HL
			RET						; Ritorna (a L2652)
			;
			; Routine 0x2652 - Continuazione della L260D
			;
L2652		LD A,D					; Copia D in A (tipo variabile)
			LD (TYPE),A				; Salva A in memoria puntata da (0x40AF) TYPE
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			LD A,(FORFLG)			; Carica in A da memoria puntata da (0x40DC) FORFLG
			OR A					; Esegue OR di A
			JP NZ,L2664				; Se diverso da zero, passa a 0x2664
			LD A,(HL)				; Carica in A da memoria puntata da (HL) 
			SUB '('					; Sottrae da A il valore 0x28 (carattere '(')				; Array?
			JP Z,L26E9				; Se zero, passa alla 0x26E9 (L26E9 ?)
L2664		XOR A					; Azzera A													; Simple variable
			LD (FORFLG),A			; Azzera memoria puntata da (0x40DC) FORFLG					; Clear "FOR" flag
			PUSH HL					; Salva HL nello stack										
			PUSH DE					; Salva DE nello stack										
			LD HL,(PRGEND)			; Carica in HL da memoria puntata da (0x40F9) PRGEND		; End of program, start of variables address
L266D		EX DE,HL				; Scambia DE ed HL
			LD HL,(VAREND)			; Carica in HL da memoria puntata da (0x40FB) VAREND		; End of variables
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			POP HL					; Recupera HL dallo stack
			JR Z,CFEVAL				; Se zero, passa a 0x268E (L268E CFEVAL)
			LD A,(DE)				; Carica in A da memoria puntata da (DE)
			LD L,A					; Copia A in L
			CP H					; Compara A con H
			INC DE					; Incrementa DE
			JR NZ,L2686				; Se diverso, passa a 0x2686
			LD A,(DE)				; Carica in A da memoria puntata da (DE)
			CP C					; Compara A con C
			JR NZ,L2686				; Se diverso, passa a 0x2686
			INC DE					; Incrementa DE
			LD A,(DE)				; Carica in A da memoria puntata da (DE)
			CP B					; Compara A con B
			JP Z,L26CC				; Se zero, passa a 0x26CC 
			;
			.BYTE 0x3E				; Esegue LD A,0x13  skip istruzione INC DE
									;   continua con la 0x2687 (L2687)
L2686		INC DE					; Incrementa DE
L2687		INC DE					; Incrementa DE
			PUSH HL					; Salva HL nello stack
			LD H,0x00				; Azzera H
			ADD HL,DE				; Somma DE ad HL
			JR L266D				; Passa a 0x266D
			
			;
			; Routine 0x268E - CFEVAL
			;
CFEVAL		LD A,H					; Copia H in A
			POP HL					; Recupera HL dallo stack
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			PUSH AF					; Salva AF nello stack
			PUSH DE					; Salva DE nello stack
			LD DE,0x24F1			; Carica in DE il valore 0x24F1
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR Z,RETNUL				; Se uguali, passa alla 0x26CF (L26CF RETNUL)
			LD DE,FRMEVL			; Carica in DE il valore 0x2543 (puntatore a L2543 FRMEVL)
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			POP DE					; Recupera DE dallo stack
			JR Z,L26D5				; Se uguali, passa alla 0x26D5 (L26D5 ?)
			POP AF					; Recupera AF dallo stack
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			PUSH HL					; Salva HL nello stack
			PUSH BC					; Salva BC nello stack
			LD C,A					; Copia A in C
			LD B,0x00				; Azzera B
			PUSH BC					; Salva BC nello stack
			INC BC					; Incrementa BC
			INC BC					; Incrementa BC
			INC BC					; Incrementa BC
			LD HL,(ARREND)			; Carica in HL da memoria puntata da (0x40FD) ARREND
			PUSH HL					; Salva HL nello stack
			ADD HL,BC				; Somma BC ad HL
			POP BC					; Recupera BC dallo stack
			PUSH HL					; Salva HL nello stack
			CALL MOVUP				; Chiama la 0x1955 (L1955 MOVUP)
			POP HL					; Recupera HL dallo stack
			LD (ARREND),HL			; Salva HL in memoria puntata da (0x40FD) ARREND
			LD H,B					; Copia B in H
			LD L,C					; Copia C in L
			LD (VAREND),HL			; Salva HL in memoria puntata da (0x40FB) VAREND
L26BE		DEC HL					; Decrementa HL
			LD (HL),0x00			; Azzera memoria puntata da (HL)
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR NZ,L26BE				; Se diverso da zero, passa a 0x26BE
			POP DE					; Recupera DE dallo stack
			LD (HL),E				; Salva E in memoria puntata da (HL)
			INC HL					; Incrementa HL
			POP DE					; Recupera DE dallo stack
			LD (HL),E				; Salva E in memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD (HL),D				; Salva D in memoria puntata da (HL)
			EX DE,HL				; Scambia DE ed HL
L26CC		INC DE					; Incrementa DE
			POP HL					; Recupera HL dallo stack
			RET						; Ritorna

			;
			; Routine 0x26CF - RETNUL  Ritorna una variabile NULLA
			;
RETNUL		LD D,A					; Copia A in D
			LD E,A					; Copia A in E
			POP AF					; Recupera AF dallo stack
			POP AF					; Recupera AF dallo stack
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			RET						; Ritorna

			;
			; Routine 0x26D5
			;
L26D5		LD (FPEXP),A			; Salva A in memoria puntata da (0x4124) FPEXP
			POP BC					; Recupera BC dallo stack
			LD H,A					; Copia A in H
			LD L,A					; Copia A in L
			LD (FPREG),HL			; Salva HL in memoria puntata da (0x4121) FPREG
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)
			JR NZ,L26E7				; Se diverso da zero, passa a 0x26E7
			LD HL,0x1928			; Carica in HL il valore 0x1928
			LD (FPREG),HL			; Salva HL in memoria puntata da (0x4121) FPREG
L26E7		POP HL					; Recupera HL dallo stack
			RET						; Ritorna

			;
			; Routine 0x26E9 - SBSCPT  Sort out subscript
			;
L26E9		PUSH HL					; Salva HL nello stack
			LD HL,(0x40AE)			; LCRFLG
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			LD D,A					; Copia A in D
L26EF		PUSH DE					; Salva DE nello stack
			PUSH BC					; Salva BC nello stack
			CALL FPSINT				; Chiama la 0x1E45 (L1E45 FPSINT)
			POP BC					; Recupera BC dallo stack
			POP AF					; Recupera AF dallo stack
			EX DE,HL				; Scambia DE ed HL
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			PUSH HL					; Salva HL nello stack
			EX DE,HL				; Scambia DE ed HL
			INC A					; Incrementa A
			LD D,A					; Copia A in D
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CP 0x2C					; Compara A con il valore 0x2C (carattere ',')
			JR Z,L26EF				; Se zero, passa a 0x26EF
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ')'				; (Carattere ')')
			LD (NXTOPR),HL			; Salva HL in memoria puntata da (0x40F3) NXTOPR
			POP HL					; Recupera HL dallo stack
			LD (0x40AE),HL			; Salva HL in memoria puntata da (0x40AE) LCRFLG
			PUSH DE					; Salva DE nello stack
			LD HL,(VAREND)			; Carica in HL da memoria puntata da (0x40FB) VAREND
			.BYTE 0x3E				; Esegue istruzione LD A,0x19  skip istruzione ADD HL,DE
									;   continua con la 0x2710 (L2710)
L270F		ADD HL,DE				; Somma DE ad HL
L2710		EX DE,HL				; Scambia DE ed HL
			LD HL,(ARREND)			; Carica in HL da memoria puntata da (0x40FD) ARREND
			EX DE,HL				; Scambia DE ed HL
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			LD A,(TYPE)				; Carica in A da memoria puntata da (0x40AF) TYPE
			JR Z,L2742				; Passa alla 0x2742 (L2742 ?)
			CP (HL)					; Compara A con memoria puntata da (HL)
			INC HL					; Incrementa HL
			JR NZ,L2727				; Se diverso da zero, passa a 0x2727
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CP C					; Compara A con C
			INC HL					; Incrementa HL
			JR NZ,L2728				; Se diverso da zero, passa a 0x2728
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			CP B					; Compara A con B
			.BYTE 0x3E				; Esegure LD A,0x23  skip istruzione INC HL
									;   continua con la 0x2728 (L2728)
L2727		INC HL					; Incrementa HL
L2728		INC HL					; Incrementa HL
			LD E,(HL)				; Carica in E da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD D,(HL)				; Carica in D da memoria puntata da (HL)
			INC HL					; Incrementa HL
			JR NZ,L270F				; Se diverso da zero, passa a 0x270F
			LD A,(0x40AE)			; Carica in HL da memoria puntata da (0x40AE) LCRFLG
			OR A					; Esegue OR di A
			LD E,ECOD12				; Carica in E il valore 0x12 (codice errore Redimensioned array)
			JP NZ,MSGERR			; Se diverso da zero, passa a 0x19A2 (L19A2 MSGERR)
			POP AF					; Recupera AF dallo stack
			SUB (HL)				; Sottrae da A memoria puntata da (HL)
			JP Z,L2795				; Se zero, passa a 0x2795
SBSCRER		LD E,ECOD10				; Carica in E il valore 0x10 (codice errore Subscript out of range)
			JP MSGERR				; Passa alla 0x19A2 (L19A2 MSGERR)
									;
L2742		LD (HL),A				; Salva A in memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD E,A					; Copia A in E
			LD D,0x00				; Azzera D
			POP AF					; Recupera AF dallo stack
			LD (HL),C				; Salva C in memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD (HL),B				; Salva B in memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD C,A					; Copia A in C, test per C livelli di stack
			CALL CHKSTK				; Chiama la 0x1963 (L1963 CHKSTK)
			INC HL					; Incrementa HL
			INC HL					; Incrementa HL
			LD (CUROPR),HL			; Salva HL in memoria puntata da (0x40D8) CUROPR
			LD (HL),C				; Salva C in memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD A,(0x40AE)			; Carica in HL da memoria puntata da (0x40AE) LCRFLG
			RLA						; Ruota A a sinistra di 1 bit
			LD A,C					; Copia C in A
L275C		LD BC,0x000B			; Carica in BC il valore 0x000B
			JR NC,L2763				; Se CY=0, passa a 0x2763
			POP BC					; Recupera BC dallo stack
			INC BC					; Incrementa BC
L2763		LD (HL),C				; Salva C in memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD (HL),B				; Salva B in memoria puntata da (HL)
			INC HL					; Incrementa HL
			PUSH AF					; Salva AF nello stack
			CALL L0BAA				; Chiama la 0x0BAA (L0BAA ?)
			POP AF					; Recupera AF dallo stack
			DEC A					; Decrementa A
			JR NZ,L275C				; Se diverso da zero, passa a 0x275C
			PUSH AF					; Salva AF nello stack
			LD B,D					; Copia D in B
			LD C,E					; Copia E in C
			EX DE,HL				; Scambia DE ed HL
			ADD HL,DE				; Somma DE ad HL
			JR C,SBSCRER			; Se CY=1, passa a 0x273D (L273D SBSCRER)
			CALL ENFMEM				; Chiama la 0x196C (L196C ENFMEM)
			LD (ARREND),HL			; Salva HL in memoria puntata da (0x40FD) ARREND
L277C		DEC HL					; Decrementa HL
			LD (HL),0x00			; Azzera memoria puntata da (HL)
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR NZ,L277C				; Se diverso da zero, passa a 0x277C
			INC BC					; Incrementa BC
			LD D,A					; Copia A in D
			LD HL,(CUROPR)			; Carica in HL da memoria puntata da (0x40D8) CUROPR
			LD E,(HL)				; Carica in E da memoria puntata da (HL)
			EX DE,HL				; Scambia DE ed HL
			ADD HL,HL				; Raddoppia HL
			ADD HL,BC				; Somma BC ad HL
			EX DE,HL				; Scambia DE ed HL
			DEC HL					; Decrementa HL
			DEC HL					; Decrementa HL
			LD (HL),E				; Salva E in memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD (HL),D				; Salva D in memoria puntata da (HL)
			INC HL					; Incrementa HL
			POP AF					; Recupera AF dallo stack
			JR C,L27C5				; Se CY=1, passa a 0x27C5
L2795		LD B,A					; Copia A in B
			LD C,A					; Copia A in C
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			INC HL					; Incrementa HL
			.BYTE 0x16				; Esegue LD D,0xE1  skip istruzione POP HL
									;   continua con la 0x279B (L279B)
L279A		POP HL					; Recupera HL dallo stack			
L279B		LD E,(HL)				; Carica in E da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD D,(HL)				; Carica in D da memoria puntata da (HL)
			INC HL					; Incrementa HL
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			PUSH AF					; Salva AF nello stack
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JP NC,SBSCRER			; Se CY=0, passa a 0x273D (L273D SBSCRER)
			CALL L0BAA				; Chiama la 0x0BAA (L0BAA ?)
			ADD HL,DE				; Somma DE ad HL
			POP AF					; Recupera AF dallo stack
			DEC A					; Decrementa A
			LD B,H					; Copia H in B
			LD C,L					; Copia L in C
			JR NZ,L279A				; Se diverso da zero, passa a 0x279A (L279A ?)
			LD A,(TYPE)				; Carica in A da memoria puntata da (0x40AF) TYPE
			LD B,H					; Copia H in B
			LD C,L					; Copia L in C
			ADD HL,HL				; Raddoppia HL
			SUB 0x04					; Sottrae da A il valore 0x04
			JR C,L27BD				; Se CY=1, passa a 0x27BD
			ADD HL,HL				; Raddoppia HL
			JR Z,L27C2				; Se zero, passa a 0x27C2
			ADD HL,HL				; Raddoppia HL
L27BD		OR A					; Esegue OR di A
			JP PO,L27C2				; Se po, passa a 0x27C2
			ADD HL,BC				; Somma BC ad HL
L27C2		POP BC					; Recupera BC dallo stack
			ADD HL,BC				; Somma BC ad HL
			EX DE,HL				; Scambia DE ed HL
L27C5		LD HL,(NXTOPR)			; Carica in HL da memoria puntata da (0x40F3) NXTOPR
			RET						; Ritorna

			;
			; Routine 0x27C9 - MEM
			;
MEM 		XOR A					; Azzera A (Tipo non valido)
			PUSH HL					; Salva HL nello stack
			LD (TYPE),A				; Azzera memoria puntata da (0x40AF) TYPE
			CALL FRE				; Chiama la 0x27D4 (L27D4 FRE)
			POP HL					; Recupera HL dallo stack
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			RET     				; Ritorna

			;
			; Routine 0x27D4 - FRE
			;
FRE			LD HL,(ARREND)			; Carica in HL da memoria puntata da (0x40FD) ARREND	; Start of free memory			
			EX DE,HL				; Scambia DE ed HL										; To DE
			LD HL,0x0000			; Azzera HL												; End of free memory
			ADD HL,SP				; Somma SP ad HL										; Current stack value
			RST VGETTYPE			; Chiama la RST 0x20 (L0020 VGETTYPE)									; Dummy argument type
			JR NZ,L27EC				; Se diverso da zero, passa a 0x27EC					; Numeric - Free variable space
			CALL L29DA				; Chiama la 0x29DA (L29DA GSTRCU)						; Current string to pool
			CALL L28E6				; Chiama la 0x28E6 (L28E6 GARBGE)						; Garbage collection
			LD HL,(STRSPC)			; Carica in HL memoria puntata da (0x40A0) STRSPC		; Bottom of string space in use STRSPC
			EX DE,HL				; Scambia DE ed HL										; To DE
			LD HL,(STRBOT)			; Carica in HL memoria puntata da (0x40D6) STRBOT		; Bottom of string space STRBOT
L27EC		LD A,L					; Copia L in A											; Get LSB of end
			SUB E					; Sottrae E da A										; Subtract LSB of beginning
			LD L,A					; Copia A in L											; Save difference if C
			LD A,H					; Copia H in A											; Get MSB of end
			SBC A,D					; Sottrae D da A										; Subtract MSB of beginning
			LD H,A					; Copia A in H										
			JP L0C66				; Passa a 0x0C66 (L0C66 ?)

			;
			; Routine 0x27F5 - POS
			;
POS			LD A,(CURPOS)			; Carica in A da memoria puntata da (0x40A6) CURPOS	; Get cursor position 
									;  continua con la 0x27F8 (L27F8 MVAU2FPR)

			;
			; Routine 0x27F8 - MVAU2FPR Salva byte A in FPREG
			;   Input: A valore byte senza segno da salvare in FPREG
			;
MVAU2FPR	LD L,A					; Copia A in L										; Put A into L
			XOR A					; Azzera A											; Zero A
			LD H,A					; Copia A in H										; Azzera H
			JP MVHL2FPR				; Passa a 0x0A9A (L0A9A MVHL2FPR)					; Return integer HL
			
			;
			; Routine 0x27FE - USR 
			;
USR			CALL L3397				; Chiama la 0x3397 (L3397 ?)
			RST VGETCH				; Chiama la RST 0x10 (L0010 VGETCH)
			CALL L252C				; Chiama la 0x252C (L252C ?)
			PUSH HL					; Salva HL nello stack
			LD HL,0x0890			; Carica in HL il valore 0x0890
			PUSH HL					; Salva HL nello stack
			LD A,(TYPE)				; Carica in A da memoria puntata da (0x40AF) TYPE
			PUSH AF					; Salva AF nello stack
			CP 0x03					; Compara A con il valore 0x03
			CALL Z,L29DA			; Se zero, chiama la 0x29DA (L29DA GSTRCU)
			POP AF					; Recupera AF dallo stack
			EX DE,HL				; Scambia DE ed HL
			LD HL,(0x408E)			; Carica in HL da memoria puntata da (0x408E)
			JP (HL)					; Passa a indirizzo puntato da (HL)

			;
			; Routine 0x2819 - EXECCV 
			;
EXECCV		PUSH HL					; Salva HL nello stack
L281A		AND 0x07				; Esegue AND di A con il valore 0x07 (maschera tipo conversione)
			LD HL,TABCONV			; Carica in HL il valore 0x18A1 (puntatore a TABCONV)
			LD C,A					; Copia A in C
			LD B,0x00				; Azzera B
			ADD HL,BC				; Somma BC ad HL, ottiene puntatore in tabella
			CALL EXECFNOP			; Chiama la 0x2586 (L2586 EXECFNOP)
			POP HL					; Recupera HL dallo stack
			RET						; Ritorna

			;
			; Routine 0x2828 - IDTEST
			;
L2828		PUSH HL					; Salva HL nello stack												; Save code string address
			LD HL,(LINEAT)			; Carica in HL memoria puntata da (0x40A2)							; Get current line number LINEAT
			INC HL					; Incrementa HL														; -1 means direct statement
			LD A,H					; Copia H in A
			OR L					; Esegue OR di A con L
			POP HL					; Recupera HL dallo stack											; Restore code string address
			RET NZ					; Se diverso da zero, ritorna										; Return if in program
			LD E,ECOD16				; Carica in E il valore 0x16 (codice errore Illegal Direct Error)	; ?ID Error
			JP MSGERR				; Passa alla 0x19A2 (L19A2 MSGERR)

			;
			; Routine 0x2836 - STR$
			;
STR			CALL NUMASC				; Chiama la 0x0FBD (L0FBD NUMASC)
			CALL CRTST				; Chiama la 0x2865 (L2865 CRTST)
			CALL L29DA				; Chiama la 0x29DA (L29DA GSTRCU)
			LD BC,0x2A2B			; Carica in BC il valore 0x2A2B
			PUSH BC					; Salva BC nello stack
L2843		LD A,(HL)				; Carica in A da memoria puntata da (HL)
			INC HL					; Incrementa HL
			PUSH HL					; Salva HL nello stack
			CALL CKSTRSPC			; Chiama la 0x28BF (L28BF CKSTRSPC)
			POP HL					; Recupera HL dallo stack
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			CALL SAVTSTR			; Chiama la 0x285A (L285A SAVTSTR)
			PUSH HL					; Salva HL nello stack
			LD L,A					; Copia A in L
			CALL L29CE				; Chiama la 0x29CE (L29CE TOSTRA)
			POP DE					; Recupera DE dallo stack
			RET     				; Ritorna

			;
			; Routine 0x2857 - MKTMPSTR  crea e salva nuova stringa temporanea
			;   Input: A=Lunghezza stringa in byte
			;
MKTMPSTR	CALL CKSTRSPC			; Chiama la 0x28BF (L28BF CKSTRSPC)						; See if enough string space
									;	continua con la 0x285A (L285A SAVTSTR)

			;
			; Routine 0x285A - SAVTSTR  Salva descrittore stringa temporanea
			;  Input:  A:  lunghezza stringa,  DE: puntatore a stringa
			;  Output: HL: puntatore a descrittore 
			;
SAVTSTR		LD HL,TMPSTR			; Carica in HL il valore 0x40D3	(puntatore a TMPSTR)		; Temporary string TMPSTR
			PUSH HL					; Salva HL nello stack									
			LD (HL),A				; Salva A in memoria puntata da (HL), lunghezza stringa		; Save length of string
			INC HL					; Incrementa HL
			LD (HL),E				; Salva E in memoria puntata da (HL), LSB indirizzo stringa	; Save LSB of address
			INC HL					; Incrementa HL											
			LD (HL),D				; Salva D in memoria puntata da (HL), MSB indirizzo stringa	; Save MSB of address
			POP HL					; Recupera HL dallo stack									; Restore pointer
			RET     				; Ritorna												

			;
			; Routine 0x2865 - CRTST Crea una stringa temporanea
			;
CRTST		DEC HL					; Decrementa HL											; DEC - INCed after
L2866		LD B,0x22				; Carica in B il valore 0x22 (carattere '"')			; Terminating quote
									;   continua con la 0x2868 (L2868 ?)

			;
			; Routine 0x2868
			;
L2868		LD D,B					; Copia B in D											; Quote to D
L2869		PUSH HL					; Salva HL nello stack									; Save start
			LD C,0xFF				; Carica in C il valore 0xFF							; Set counter to -1
L286C		INC HL					; Incrementa HL											; Move on
			LD A,(HL)				; Carica in A il valore di (HL)							; Get byte
			INC C					; Incrementa C											; Count bytes
			OR A					; Esegue OR di A										; End of line?
			JR Z,L2878				; Se zero, passa a 0x2878								; Yes - Create string entry
			CP D					; Compara con D											; Terminator D found?
			JR Z,L2878				; Se uguale, passa a 0x2878								; Yes - Create string entry
			CP B					; Compara con B											; Terminator B found?
			JR NZ,L286C				; Se diverso passa a 0x286C								; No - Keep looking
L2878		CP 0x22					; Compara con il valore 0x22 (carattere '"')			; End with '"'?
			CALL Z,GETCH			; Se uguale, chiama la 0x1D78 (L1D78 ?)					; Yes - Get next character
			EX (SP),HL				; Scambia HL con (SP)									; Starting quote
			INC HL					; Incrementa HL											; First byte of string
			EX DE,HL				; Scambia DE ed HL										; To DE
			LD A,C					; Copia C in A											; Get length
			CALL SAVTSTR			; Chiama la 0x285A (L285A SAVTSTR)						; Create string entry
									;   continua con la 0x2884 (L2884 TSTOPL)

			;
			; Routine 0x2884 - TSTOPL  Temporary string to pool
			;
L2884		LD DE,TMPSTR			; Carica in DE il valore 0x40D3 (puntatore a TMPSTR)		; Temporary string 
			.BYTE 0x3E				; Esegue LD A,0xD5  skip istruzione PUSH DE
									;   continua con la 0x2889 (L2889)
L2888		PUSH DE					; Salva DE nello stack
L2889		LD HL,(TMSTPT)			; Cairica in HL il valore puntato da (0x40B3) TMSTPT	; Temporary string pool pointer
			LD (FPREG),HL			; Salva HL in memoria puntata da (0x4121) FPREG			; Save address of string ptr	
			LD A,0x03				; Carica in A il valore 0x03 (Tipo stringa)
			LD (TYPE),A				; Salva A in memoria puntata da (0x40AF) TYPE			; Set type to string
			CALL CPYVDEHL			; Chiama la 0x09D3 (L09D3 CPYVDEHL)						; Move string to pool
			LD DE,STRBOT			; Carica in DE il valore 0x40D6	(puntatore a STRBOT)	
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)					; Out of string pool?
			LD (TMSTPT),HL			; Salva HL in memoria puntata da (0x40B3) TMSTPT		; Save new pointer
			POP HL					; Recupara HL dallo stack								; Restore code string address
			LD A,(HL)				; Carica in A il valore puntato da (HL)					; Get next code byte
			RET NZ					; Se diverso da zero, ritorna							; Return if pool OK
			LD E,ECOD1E				; Carica in E il valore 0x1E (codice errrore String formula too complex)	; ?ST Error
			JP MSGERR				; Passa a 0x19A2 (L19A2 MSGERR)							; String pool overflow

			;
			; Routine 0x28A6 - INCHLPRS	 Incrementa posizione in HL e visualizza messaggio puntato da HL
			;
INCHLPRS	INC HL					; Incrementa HL
									; continua con la 0x28A7 (L28A7 PRS)

			;
			; Routine 0x28A7 - PRS Crea la stringa e visualizza messaggio puntato da (HL)
			;
PRS			CALL CRTST				; Chiama la 0x2865 (L2865 CRTST)
									;   contrinua con la 0x28AA (L28AA PRSHL)

			;
			; Routine 0x28AA - PRSHL  Visualizza messaggio puntato da (HL)
			;
PRSHL		CALL L29DA				; Chiama la 0x29DA (L29DA GSTRCU)
			CALL PHL2BCD0			; Chiama la 0x09C4 (L09C4 PHL2BCD0)
			INC D					; Incrementa D
L28B1		DEC D					; Decrementa D
			RET Z					; Se D=0, ritorna
			LD A,(BC)				; Carica in A il valore puntato da (BC)
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
			CP 0x0D					; Compara A con il valore 0x0D (Carattere CR)
			CALL Z,L2103			; Se uguale, chiama la 0x2103 (L2103 ?)
			INC BC					; Incrementa BC
			JR L28B1				; Passa a 0x28b1

			;
			; Routine 0x28BF - CKSTRSPC  test disponibilità memoria per nuova stringa
			;   Input: A  lunghezza stringa richiesta in byte
			;
CKSTRSPC	OR A					; Esegue OR di A
			.BYTE 0x0E				; Esegue LD C,0xF1  skip istruzione POP AF
									;  continua con la 0x28C2 (L28C2)
L28C1		POP AF					; Recupera AF dallo stack
L28C2		PUSH AF					; Salva AF nello stack
			LD HL,(STRSPC)			; Carica in HL il valore puntato da (0x40A0) STRSPC
			EX DE,HL				; Scambia DE ed HL
			LD HL,(STRBOT)			; Carica in HL il valore puntato da (0x40D6) STRBOT
			CPL     				; Complementa A
			LD C,A					; Copia A in C
			LD B,0xFF				; Carica in B il valore 0xFF
			ADD HL,BC				; Somma BC ad HL
			INC HL					; Incrementa HL
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR C,L28DA				; Se CY=1 salta a 0x28DA 
			LD (STRBOT),HL			; Salva HL in memoria puntata da (0x40D6) STRBOT
			INC HL					; Incrementa HL
			EX DE,HL				; Scambia DE ed HL
									;   continua con la 0x28D8 (L28D8 POPAF)
			
			;
			; Routine 0x28D8 - POPAF  recupera AF dallo stack e termina
			;
POPAF		POP AF					; Recupera AF dallo stack
			RET     				; Ritorna
			;
L28DA		POP AF					; Recupera AF dallo stack
			LD E,ECOD1A				; Carica in E il valore 0x1A (codice di errore 0x1A Out of stringa space)
			JP Z,MSGERR				; Se zero, passa a 0x19A2 (L19A2 MSGERR)
			CP A					; Compara con A
			PUSH AF					; Salva AF nello stack
			LD BC,L28C1				; Carica in BC il valore 0x28C1 (puntatore a L28C1)
			PUSH BC					; Salva BC nello stack
									;   continua con la 0x28E6 (L28E6 GARBGE)

			;
			; Routine 0x28E6 - GARBGE  Garbage collection
			;
L28E6		LD HL,(EOFRAM)			; Carica in HL il valore puntato da (0x40B1) EOFRAM		; Get End of RAM EOFRAM
			LD (STRBOT),HL			; Salva HL in memoria puntata da (0x40D6) STRBOT
			LD HL,0x0000			; Azzera HL
			PUSH HL					; Salva HL nello stack
			LD HL,(STRSPC)			; Carica in HL il valore puntato da (0x40A0) STRSPC
			PUSH HL					; Salva HL nello stack
			LD HL,TSAREA			; Carica in HL il valore 0x40B5 (puntatore a TSAREA)
			EX DE,HL				; Scambia DE ed HL
			LD HL,(TMSTPT)			; Carica in HL il valore puntato da (0x40B3) TMSTPT
			EX DE,HL				; Scambia DE ed HL
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			LD BC,0x28F7			; Carica in BC il valore 0x28F7
			JP NZ,L294A				; Se diverso da zero, passa a 0x294A 
			LD HL,(PRGEND)			; Carica in HL il valore puntato da (0x40F9) PRGEND
L2906		EX DE,HL				; Scambia DE ed HL
			LD HL,(VAREND)			; Carica in HL il valore puntato da (0x40FB) VAREND
			EX DE,HL				; Scambia DE ed HL
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR Z,L2921				; Se uguale a zero, passa a 0x2921 (L2921 ?)
			LD A,(HL)				; Carica in A dalla memoria puntata da (HL)
			INC HL					; Incrementa HL
			INC HL					; Incrementa HL
			INC HL					; Incrementa HL
			CP 0x03					; Compara A con 0x03
			JR NZ,L291A				; Se diverso da zero, passa a 0x291A 
			CALL L294B				; Chiama la 0x294B (L294B ?)
			XOR A					; Azzera A
L291A		LD E,A					; Copia A in E
			LD D,0x00				; Azzera D
			ADD HL,DE				; Somma DE ad HL
			JR L2906				; Passa a 0x2906
			;
L2920		POP BC					; Recupera BC dallo stack
			;
L2921		EX DE,HL				; Scambia DE ed HL
			LD HL,(ARREND)			; Carica in HL il valore puntato da (0x40FD) ARREND
			EX DE,HL				; Scambia DE ed HL
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JP Z,L296B				; Se uguale a zero, passa a 0x296B
			LD A,(HL)				; Carica in A dalla memoria puntata da (HL)
			INC HL					; Incremaneta HL
			CALL PHL2BCDE			; Chiama la 0x09C2 (L09C2 PHL2BCDE)
			PUSH HL					; Salva HL nello stack
			ADD HL,BC				; Somma BC ad HL
			CP 0x03					; Compara A con 0x03
			JR NZ,L2920				; Se diverso, passa a 0x2920
			LD (CUROPR),HL			; Salva HL nella memoria puntata da (0x40D8) CUROPR
			POP HL					; Recupera HL dallo stack
			LD C,(HL)				; Carica in C valore puntato da (HL)
			LD B,0x00				; Azzera B
			ADD HL,BC				; Somma BC ad HL
			ADD HL,BC				; Somma A ad HL
			INC HL					; Incrementa HL
			EX DE,HL				; Scambia DE ed HL
			LD HL,(CUROPR)			; Carica in HL da memoria puntata da (0x40D8) CUROPR
			EX DE,HL				; Scambia DE ed HL
			RST VCPDEHL				; Chiama la RST 0x18
			;
			JR Z,L2921				; Se uguale a zero, passa a 0x2921
			LD BC,0x293F			; Carica in BC il valore 0x293F
L294A		PUSH BC					; Salva BC nello stack
L294B		XOR A					; Azzera A
			OR (HL)					; Esegue OR con valore puntato da (HL)
			INC HL					; Incrementa HL
			LD E,(HL)				; Carica in E il valore puntato da (HL)
			INC HL					; Incrementa HL
			LD D,(HL)				; Carica in D il valore puntato da (HL)
			INC HL					; Incrementa HL
			RET Z					; Se uguale a zero, ritorna
			;
			LD B,H					; Copia H in B
			LD C,L					; Copia L in C
			LD HL,(STRBOT)			; Carica in HL da memoria puntata da (0x40D6) STRBOT
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			LD H,B					; Copia B in H
			LD L,C					; Copia C in L
			RET C					; Se CY=1, ritorna
			;
			POP HL					; Recupera HL dallo stack
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			PUSH HL					; Salva HL nello stack
			LD H,B					; Copia B in H
			LD L,C					; Copia C in L
			RET NC					; Se CY=0, ritorna
			;
			POP BC					; Recupera BC dallo stack
			POP AF					; Recupera A Fine dallo stack
			POP AF					; Recupera AF dallo stack
			PUSH HL					; Salva HL nello stack
			PUSH DE					; Salva DE nello stack
			PUSH BC					; Salva BC nello stack
			RET     				; Ritorna
			;
L296B		POP DE					; Recupera DE dallo stack
			POP HL					; Recupera HL dallo stack
			LD A,L					; Copia L in A
			OR H					; Esegue OR con H
			RET Z					; Se zero, rirotna

			;
			; Tabella ??
			;
			.BYTE 0x2B, 0x46
			.BYTE 0x2B, 0x4E, 0xE5
			.BYTE 0x2B, 0x6E, 0x26
			.BYTE 0x00, 0x09
			.BYTE 0x50, 0x59
			.BYTE 0x2B, 0x44, 0x4D
			.BYTE 0x2A, 0xD6, 0x40
			.BYTE 0xCD, 0x58, 0x19
			.BYTE 0xE1, 0x71, 0x23
			.BYTE 0x70, 0x69, 0x60
			.BYTE 0x2B, 0xC3, 0xE9
			.BYTE 0x28

			;
			; Routine 0x298F - CONCAT  Concatena due stringhe
			;
L298F		PUSH BC					; Salva BC nello stack											; Save prec' opr & code string
			PUSH HL					; Salva HL nello stack											; 
			LD HL,(FPREG)			; Carica in HL da memoria puntata da (0x4121) FPREG				; Get first string
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)						; Save first string
			CALL L249F				; Chiama la 0x249F (L249F OPRND)								; Get second string
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)						; Restore first string
			CALL TSTSTR				; Chiama la 0x0AF4 (L0AF4 TSTSTR)								; Make sure it's a string
			LD A,(HL)				; Carica in A da memoria puntata da (HL) 						; Get length of second string
			PUSH HL					; Salva HL nello stack											; Save first string
			LD HL,(FPREG)			; Carica in HL da memoria puntata da (0x4121) FPREG				; Get second string
			PUSH HL					; Salva HL nello stack											; Save second string
			ADD A,(HL)				; Somma A a memoria puntata da (HL)								; Add length of second string
			LD E,ECOD1C				; Carica in E il valore 0x1C (Codice errore String Too Long)	; ?LS Error
			JP C,MSGERR				; Se CY=1, passa a 0x19A2 (L19A2 MSGERR)						; String too long - Error
			CALL MKTMPSTR			; Chiama la 0x2857 (L2857 MKTMPSTR)								; Make temporary string
			POP DE					; Recupera DE dallo stack										; Get second string to DE
			CALL L29DE				; Chiama la 0x29DE (L29DE GSTRDE)								; Move to string pool if needed
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)						; Get first string
			CALL L29DD				; Chiama la 0x29DD (L29DD ?)									; Move to string pool if needed
			PUSH HL					; Salva HL nello stack											; Save first string
			LD HL,(TSADD)			; Carica in HL da memoria puntata da (0x40D4) TSADD				; Temporary string address
			EX DE,HL				; Scambia DE ed HL												; To DE
			CALL L29C6				; Chiama la 0x29C6 (L29C6 SSTSA)								; First string to string area
			CALL L29C6				; Chiama la 0x29C6 (L29C6 SSTSA)								; Second string to string area
			LD HL,0x2349				; Carica in HL il valore 0x2349									; Return to evaluation loop
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)						; Save return,get code string
			PUSH HL					; Salva HL nello stack											; Save code string address
			JP L2884				; Passa alla 0x2884 (L2884 ?)									; To temporary string to pool

			;
			; Routine 0x29C6 - SSTSA  Copia stringa puntata da HL in memoria puntata da DE
			;   Input: HL puntatore a stringa, DE puntatore a memoria destinazione
			;
L29C6		POP HL					; Recupera HL dallo stack
			EX (SP),HL				; Scambia HL con memoria puntata da (SP)
			LD A,(HL)				; Carica in A da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD B,(HL)				; Carica in B da memoria puntata da (HL)
			LD L,A					; Copia A in L
									;   continua con 0x29CE (L29CE TOSTRA)

			;
			; Routine 0x29CE - TOSTRA  Copia da (BC) in (DE) per L byte
			;  Input: BC indirizzo sorgente, DE indirizzo destinazione, L numero byte da copiare
			;
L29CE		INC L					; Incrementa L
L29CF		DEC L					; Decrementa L
			RET Z					; Se zero, ritorna
			LD  A,(BC)				; Carica in A da memoria puntata da (BC)
			LD  (DE),A				; Salva A in memoria puntata da (DE)
			INC BC					; Incrementa BC
			INC DE					; Incrementa DE
			JR L29CF				; Passa a 0x29CF, loop

			;
			; Routine 0x29D7 - GETSTR
			;
L29D7		CALL TSTSTR				; Chiama la 0x0AF4 (L0AF4 TSTSTR)
									;   continua con la 0x29DA (L29DA GSTRCU)

			;
			; Routine 0x29DA - GSTRCU  Salva stringa corrente nel pool
			;
L29DA		LD HL,(FPREG)			; Carica in HL memoria puntata da (0x4121) FPREG	
									;  continua con 0x29DD (L29DD GSTRHL)

			;
			; Routine 0x29DD - GSTRHL  Salva stringa puntata da HL nel pool
			;
L29DD		EX DE,HL				; Scambia DE ed HL
									;  continua con 0x29DE (L29DE GSTRDE)

			;
			; Routine 0x29DE - GSTRDE  Salva stringa puntata da DE nel pool
			;
L29DE		CALL L29F5				; Chiama la 0x29F5 (L29F5 BAKTMP)
			EX DE,HL				; Scambia DE ed HL
			RET NZ					; Se diverso da zero, ritorna
			PUSH DE					; Salva DE nello stack
			LD D,B					; Copia B in D
			LD E,C					; Copia C in E
			DEC DE					; Decrementa DE
			LD C,(HL)				; Carica in C da memoria puntata da (HL)
			LD HL,(STRBOT)			; Carica in HL da memoria puntata da (0x40D6) STRBOT
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR NZ,L29F3				; Se diverso da zero, passa a 0x29F3
			LD B,A					; Copia A in B
			ADD HL,BC				; Somma BC ad HL
			LD (STRBOT),HL			; Salva HL in memoria puntata da (0x40D6) STRBOT
L29F3		POP HL					; Recupera HL dallo stack
			RET     				; Ritorna

			;
			; Routine 0x29F5 - BAKTMP
			;
L29F5		LD HL,(TMSTPT)			; Carica HL da memoria puntata da (0x40B3) TMSTPT			; Get temporary string pool top
			DEC HL					; Decrementa HL												; Back
			LD B,(HL)				; Carica in B da memoria puntata da (HL)					; Get MSB of address
			DEC HL					; Decrementa HL												; Back
			LD C,(HL)				; Carica in C da memoria puntata da (HL)					; Get LSB of address
			DEC HL					; Decrementa HL												; Back
			RST VCPDEHL				; Chiama la RST 0x18 (L0018 VCPDEHL)						; Back
			RET NZ					; Se diverso da zero, ritorna								; String last in string pool?
			LD (TMSTPT),HL			; Savla HL in memoria puntata da (0x40B3) TMSTPT			; Yes - Leave it
			RET     				; Ritorna													; Save new string pool top

			;
			; Routine 0x2A03 - LEN
			;
LEN			LD BC,MVAU2FPR			; Carica in BC il valore 0x27F8 (punta a 0x27F8 MVAU2FPR)
			PUSH BC					; Salva BC nello stack
									;   continua con la 0x2A07 (L2A07 GETLEN)

			;
			; Routine 0x2A07 - GETLEN  Ottiene lunghezza stringa
			;
GETLEN		CALL L29D7				; Chiama la 0x29D7 (L29D7 GETSTR)
			XOR A					; Azzera A
			LD D,A					; Copia A in D
			LD A,(HL)				; Carica in A la memoria puntata da (HL)
			OR A					; Esegue OR di A
			RET     				; Ritorna

			;
			; Routine 0x2A0F - ASC
			;
ASC			LD BC,MVAU2FPR			; Carica in BC il valore 0x27F8 (Punta a 0x27F8 MVAU2FPR)
			PUSH BC					; Salva BC nello stack
									;   continua con la 0x2A13 (L2A13 GTFLNM)

			;
			; Routine 0x2A13 - GTFLNM  Ottiene nome file dal testo
			;
L2A13		CALL GETLEN				; Chiama la 0x2A07 (L2A07 GETLEN)
			JP Z,IFERR				; Se zero, passa alla 0x1E4A (L1E4A IFERR)
			INC HL					; Incrementa HL
			LD E,(HL)				; Carica in E da memoria puntata da (HL)
			INC HL					; Incrementa HL
			LD D,(HL)				; Carica in D da memoria puntata da (HL)
			LD A,(DE)				; Carica in A da memoria puntata da (DE)
			RET     				; Ritorna

			;
			; Routine 0x2A1F - CHR$
			;
CHR			LD A,0x01				; Carica in A il valore 0x01 (lunghezza stringa richiesta)
			CALL MKTMPSTR			; Chiama la 0x2857 (L2857 MKTMPSTR)
			CALL L2B1F				; Chiama la 0x2B1F (L2B1F ?)
			LD HL,(TSADD)			; Carica in HL da memoria puntata da (0x40D4) TSADD
			LD (HL),E				; Salva E in memoria puntata da (HL), salva carattere stringa in memoria 
L2A2B		POP BC					; Recupera BC dallo stack
			JP L2884				; Passa a 0x2884 (L2884 ?)
			
			;
			; Routine 0x2A2F - STRING$
			;
STRING		RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE '('			; (carattere '(')
			CALL GETBYT			; Chiama la 0x2B1C (L2B1C GETBYT)
			PUSH DE				; Salva DE nello stack
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','			; (carattere ',')
			CALL EVAL			; Chiama la 0x2337 (L2337 EVAL)
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ')'			; (carattere ')')
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			PUSH HL				; Salva HL nello stack
			RST VGETTYPE		; Chiama la RST 0x20 (L0020 VGETTYPE)
			JR Z,L2A47			; Se zero, passa a 0x2A47
			CALL L2B1F			; Chiama la 0x2B1F (L2B1F ?)
			JR L2A4A			; Passa a 0x2A4A
L2A47		CALL L2A13			; Chiama la 0x2A13 (L2A13 GTFLNM)
L2A4A		POP DE				; Recupera DE dallo stack
			PUSH AF				; Salva AF nello stack
			PUSH AF				; Salva AF nello stack
			LD A,E				; Copia E in A
			CALL MKTMPSTR		; Chiama la 0x2857 (L2857 MKTMPSTR)
			LD E,A				; Copia A in E
			POP AF				; Recupera AF dallo stack
			INC E				; Incrementa E
			DEC E				; Decrementa E
			JR Z,L2A2B			; Se zero, passa a 0x2A2B
			LD HL,(TSADD)		; Carica in HL da memoria puntata da (0x40D4) TSADD
L2A5A		LD (HL),A			; Salva A in memoria putnata da (HL)
			INC HL				; Incrementa HL
			DEC E				; Decrementa E
			JR NZ,L2A5A			; Se diverso da zero, passa a 0x2A5A
			JR L2A2B			; Passa a 0x2A2B

			;
			; Routine 0x2A61 - LEFT$
			;
LEFT		CALL L2ADF			; Chiama la 0x2ADF (L2ADF ?)
			XOR A				; Azzera A
L2A65		EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			LD C,A				; Copia A in C
			
			.BYTE 0x3E			; Esegue LD A,0xE5  skip istruzione PUSH HL
								;   continua con 0x2469 (L2469)
L2A68		PUSH HL				; Salva HL nello stack
L2A69		PUSH HL				; Salva HL nello stack
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			CP B				; Compara A con B
			JR C,L2A70			; Se CY=1, passa a 0x2A70 ???
			LD A,B				; Copia H in A
L2A6F		.BYTE 0x11			; Esegue LD DE,0x000E  skip istruzione LD C,0x00
								;   continua con la 0x2A72 (L2A72)
L2A70		LD C,0x00			; Azzera C
L2A72		PUSH BC				; Salva BC nello stack
			CALL CKSTRSPC		; Chiama la 0x28BF (L28BF CKSTRSPC)
			POP BC				; Recupera BC dallo stack
			POP HL				; Recupera HL dallo stack
			PUSH HL				; Salva HL nello stack
			INC HL				; Incrementa HL
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD H,(HL)			; Carica in H da memoria puntata da (HL)
			LD L,B				; Copia B in L
			LD B,0x00			; Azzera B
			ADD HL,BC			; Somma DE ad HL
			LD B,H				; Copia H in B
			LD C,L				; Copia L in C
			CALL SAVTSTR		; Chiama la 0x285A (L285A SAVTSTR)
			LD L,A				; Copia A in L
			CALL L29CE			; Chiama la 0x29CE (L29CE TOSTRA)
			POP DE				; Recupera DE dallo stack
			CALL L29DE			; Chiama la 0x29DE (L29DE GSTRDE)
			JP L2884			; Passa a 0x2884

			; 
			; Routine 0x2A91 - RIGHT$
			;
RIGHT		CALL L2ADF			; Chiama la 0x2ADF (L2ADF ?)
			POP DE				; Recupera DE dallo stack
			PUSH DE				; Salva DE nello stack
			LD A,(DE)			; Carica in A da memoria puntata da (DE)
			SUB B				; Sottrae B da A
			JR L2A65			; Passa a 0x2A65 (L2A65 ?)

			; 
			; Routine 0x2A9A - MID$
			;  Output: B ?
			;
MID			EX DE,HL			; Scambia DE ed HL								; Get code string address
			LD A,(HL)			; Carica in A da memoria puntata da (HL)        ; Get next byte ',' or ")"
			CALL L2AE2			; Chiama la 0x2AE2 (L2AE2 ?)					; Get number supplied
			INC B				; Incrementa B                                  ; Is it character zero?
			DEC B				; Decrementa B                                  ; 
			JP Z,IFERR			; Se zero, passa alla 0x1E4A (L1E4A IFERR)      ; Yes - Error
			PUSH BC				; Salva BC nello stack                          ; Save starting position
			LD E,0xFF			; Carica in E il valore 0xFF                    ; All of string
			CP 0x29				; Compara A con il valore 0x29 (carattere ')')  ; Any length given?
			JR Z,L2AB0			; Se uguale, passa a 0x2AB0                     ; No - Rest of string
			RST VCKCHAR			; Chiama la RST 0x08 (Check sintassi)           ; Make sure ',' follows
			.BYTE ','			; (carattere ',')
			CALL GETBYT			; Chiama la 0x2B1C (L2B1C GETBYT)
L2AB0		RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ')'			; (carattere ')')
			POP AF				; Recupera AF dallo stack
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			LD BC,L2A69			; Carica in BC il valore 0x2A69
			PUSH BC				; Salva BC nello stack
			DEC A				; Decrementa A
			CP (HL)				; Compara A con memoria puntata da (HL)
			LD B,0x00			; Azzera B
			RET NC				; Se CY=0, ritorna
			LD C,A				; Copia A in C
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			SUB C				; Sottrae da A il valore di C
			CP E				; Compara A con E
			LD B,A				; Copia A in B
			RET C				; Se CY=1, ritorna
			LD B,E				; Copia E in B
			RET     			; Termina

			; 
			; Routine 0x2AC5 - VAL
			;
VAL			CALL GETLEN			; Chiama la 0x2A07 (L2A07 GETLEN)
			JP Z,MVAU2FPR		; Se zero, passa a 0x27F8 (L27F8 MVAU2FPR)
			LD E,A				; Copia A in E
			INC HL				; Incrementa HL
			LD A,(HL)			; Carica in A memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD H,(HL)			; Carica in H memoria puntata da (HL)
			LD L,A				; Copia A in L
			PUSH HL				; Salva HL nello stack
			ADD HL,DE			; Somma DE ad HL
			LD B,(HL)			; Carica in B memoria puntata da (HL)
			LD (HL),D			; Salva D in memoria puntata da (HL)
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			PUSH BC				; Salva BC nello stack
			LD A,(HL)			; Carica in A memoria puntata da (HL)
			CALL L0E65			; Chiama la 0x0E65
			POP BC				; Recupera BC dallo stack
			POP HL				; Recupera HL dallo stack
			LD (HL),B			; Salva B in memoria puntata da (HL)
			RET     			; Ritorna

			; 
			; Routine 0x2ADF - LFRGNM
			;
L2ADF		EX DE,HL			; Scambia DE ed HL
			RST VCKCHAR			; Chiama la RST 0x08 (Check sintassi)
			.BYTE ')'			; (carattere ')')
L2AE2		POP BC				; Recupera BC dallo stack
			POP DE				; Recupera DE dallo stack
			PUSH BC				; Salva BC nello stack
			LD B,E				; Copia E in B
			RET     			; Ritorna

			; 
			; Routine 0x2AE7
			;
L2AE7		CP 0x7A				; Compara A con il valore 0x7A
			JP NZ,SNERR			; Se diverso, passa a 0x1997 (L1997 SNERR)
			RET					; Ritorna

			NOP					;
			NOP					;

			;
			; Routine 0x2AEF - INP
			;
INP			CALL L2B1F			; Chiama la 0x2B1F (MAKINT)						Make it integer A
			LD (0x4094),A		; Salva A in memoria puntata da (0x4094)        Set input port (INPORT)
			CALL GENINP			; Chiama la 0x4093 (L4093 GENINP)				Get input from port
			JP MVAU2FPR			; Passa a 0x27F8 (L27F8 MVAU2FPR)               Return integer A 

			;
			; Routine 0x2AFB - OUT
			;
OUT			CALL L2B0E			; Chiama la 0x2B0E (SETIO)			Set up port number
			JP GENOUT			; Passa a 0x4096 (L4096 GENOUT)		Output data and return

			;
			; Routine 0x2B01 - GETNSINT  Passa al prossimo carattere e legge un intero (da -32768 a 32767)
			;   Input: HL=puntatore-1 al valore ASCII 
			;  Output: DE=valore letto
			;		    A=numero cifre
			;
GETNSINT		RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
								;   continua con la 0x2B02 (L2B02 GETSINT)

			;
			; Routine 0x2B02 - GETSINT  Legge un intero (da -32768 a 32767)
			;  Input:  HL=puntatores al valore ASCII 
			;  Output: DE=valore letto
			;		    A=numero cifre
			;
GETSINT		CALL EVAL			; Chiama la 0x2337 (L2337 EVAL)
L2B05		PUSH HL				; Salva HL nello stack
			CALL CINT			; Chiama la 0x0A7F (L0A7F CINT)
			EX DE,HL			; Scambia DE ed HL
			POP HL				; Recupera HL dallo stack
			LD A,D				; Copia D in A
			OR A				; Esegue OR di A
			RET					; Ritorna

			;
			; Routine 0x2B0E (SETIO)
			;
L2B0E		CALL GETBYT			; Chiama la 0x2B1C (L2B1C GETBYT)
			LD (0x4094),A		; Salva A in memoria puntata da (0x4094 INPORT)
			LD (0x4097),A		; Salva A in memoria puntata da (0x4097 OTPORT)
			RST VCKCHAR			; Chiama la RST 0x08 (Check sintassi)
			.BYTE ','			; (carattere ',')
			JR GETBYT			; Passa alla 0x2B1C (L2B1C GETBYT)

			;
			; Routine 0x2B1B - FNDNUM - Evaluate expression
L2B1B		RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
								;  continua con la 0x2B1C (L2B1C GETBYT)
		
			;
			; Routine 0x2B1C - GETBYT Input valore byte (0-255)
			;  Output: A=E=valore in input
			;
GETBYT		CALL EVAL			; Chiama la 0x2337 (L2337 EVAL)
L2B1F		CALL L2B05			; Chiama la 0x2B05 (L2B05 MAPINT)
			JP NZ,IFERR			; Se diverso da zero, passa alla 0x1E4A (L1E4A IFERR)
			DEC HL				; Decrementa HL
			RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
			LD A,E				; Copia E in A
			RET     			; Ritorna

			;
			; Routine 0x2B29 - LLIST
			;
LLIST		LD A,0x01			; Carica in A il valore 0x01 (uscita su stampante)
			LD (DEVOUT),A		; Salva A in memoria puntata da (0x409C) DEVOUT
								;   continua con la 0x2B2E (L2B2E LIST)

			;
			; Routine 0x2B2E - LIST
			;
LIST		POP BC				; Recupera BC dallo stack
			CALL L1B10			; Chiama la 0x1B10 (L1B10 ?)
			PUSH BC				; Salva BC nello stack
L2B33		LD HL,0xFFFF		; Carica in HL il valore 0xFFFF (nessun numero di linea)
			LD (LINEAT),HL		; Salva HL in memoria puntata da (0x40A2) LINEAT
			POP HL				; Recupera HL dallo stack
			POP DE				; Recupera DE dallo stack
			LD C,(HL)			; Carica in C da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD A,B				; Copia B in A
			OR C				; Esegue OR di A e C
			JP Z,BASMAIN		; Se zero, passa a 0x1A19 (L1A19 BASMAIN)
			NOP					;
			NOP					;
			NOP					;
			CALL L1D9B			; Chiama la 0x1D8B (L1D9B TSTBRK)
			PUSH BC				; Salva BC nello stack
			LD C,(HL)			; Carica in C da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			INC HL				; Incrementa HL
			PUSH BC				; Salva BC nello stack
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			EX DE,HL			; Scambia DE ed HL
			RST VCPDEHL			; Chiama la RST 0x18 (L0018 VCPDEHL)
			POP BC				; Recupera BC dallo stack
			JP C,BASMAIN2		; Se CY=1, passa a 0x1A18 (L1A18 BASMAIN2)
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			PUSH HL				; Salva HL nello stack
			PUSH BC				; Salva BC nello stack
			EX DE,HL			; Scambia DE ed HL 
			LD (CUREDLN),HL		; Salva HL in memoria puntata da (0x40EC) CUREDLN
			CALL PRNTHL			; Chiama la 0x0FAF (L0FAF PRNTHL)
			LD A,' '			; Carica in A il valore 0x20 (carattere ' ')
			POP HL				; Recupera HL dallo stack
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			CALL L2B7E			; Chiama la 0x2B7E (L2B7E ?)
			LD HL,(PBUFFER)		; Carica in A da memoria puntata da (0x40A7) PBUFFER
			CALL L2B75			; Chiama la 0x2B75 (L2B75 ?)
			CALL PRNTCR			; Chiama la 0x20FE (L20FE ?)
			JR L2B33			; Passa a 0x2B33
L2B75		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			OR A				; Esegue OR di A
			RET Z				; Se zero, ritorna
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			INC HL				; Incrementa HL
			JR L2B75			; Passa a 0x2B75, ciclo

			;
			; Routine 0x2B7E
			;
L2B7E		PUSH HL				; Salva HL nello stack
			LD HL,(PBUFFER)		; Carica in HL da memoria puntata da (0x40A7) PBUFFER
			LD B,H				; Copia H in B
			LD C,L				; Copia L in C
			POP HL				; Recupera HL dallo stack
			LD D,0xFF			; Carica in D il valore 0xFF
			JR L2B8C			; Passa a 0x2B8C (L2B8C ?)

			;
			; Routine 0x2B89
			;
L2B89		INC BC				; Incrementa BC
			DEC D				; Decrementa D
			RET Z				; Se zero, ritorna

			;
			; Routine 0x2B8C
			;
L2B8C		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			OR A				; Esegue OR di A
			INC HL				; Incrementa HL
			LD (BC),A			; Salva A in memoria puntata da (BC)
			RET Z				; Se zero, ritorna
			JP P,L2B89			; Se positivo, passa a 0x2B89 (L2B89 ?)
			CP 0xFB				; Compara A con il valore 0xFB
			JR NZ,L2BA0			; Se diverso, passa a 0x2BA0
			DEC BC				; Decrementa BC
			DEC BC				; Decrementa BC
			DEC BC				; Decrementa BC
			DEC BC				; Decrementa BC
			INC D				; Incrementa D
			INC D				; Incrementa D
			INC D				; Incrementa D
			INC D				; Incrementa D
L2BA0		CP 0x95				; Compara A con il valore 0x95
			CALL Z,L0B24		; Se uguale, chiama la 0x0B24 (L0B24 ?)
			SUB 0x7F			; Sottrae da A il valore 0x7F
			PUSH HL				; Salva HL nello stack
			LD E,A				; Copia A in E
			LD HL,KWORDS		; Carica in HL il valore 0x1650 (inizio tabella keyword KWORDS)
L2BAC		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			OR A				; Esegue OR di A
			INC HL				; Incrementa HL
			JP P,L2BAC			; Se positivo, passa a 0x2BAC (ciclo ricerca inizio keyword)
			DEC E				; Decrementa E
			JR NZ,L2BAC			; Se diverso da zero, passa a 0x2BAC
			AND 0x7F			; Esegue AND con valore 0x7F (azzera bit7)
L2BB7		LD (BC),A			; Salva A in memoria puntata da (BC)
			INC BC				; Incrementa BC
			DEC D				; Decrementa D
			JP Z,POPAF			; Se zero, passa a 0x28D8 (L28D8 POPAF), recupera AF e ritorna
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			INC HL				; Incrementa HL
			OR A				; Esegue OR di A
			JP P,L2BB7			; Se positivo, passa a 0x2BB7 (ciclo copia keyword)
			POP HL				; Recupera HL dallo stack
			JR L2B8C			; Passa a 0x2B8C

			;
			; Routine 0x2BC6 - DELETE 
			;			
DELETE		CALL L1B10			; Chiama la 0x1B10 (L1B10 ?)
			POP DE				; Recupera DE dallo stack
			PUSH BC				; Salva BC nello stack
			PUSH BC				; Salva BC nello stack
			CALL SRCHLN			; Chiama la 0x1B2C (L1B2C SRCHLN)
			JR NC,L2BD6			; Se CY=0, passa a 0x2BD6
			LD D,H				; Copia H in D
			LD E,L				; Copia L in E
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			PUSH HL				; Salva HL nello stack
			RST VCPDEHL			; Chiama la RST 0x18 (L0018 VCPDEHL)
L2BD6		JP NC,IFERR			; Se CY=0, passa alla 0x1E4A (L1E4A IFERR)
			LD HL,MREADY		; Carica in HL il valore 0x1929 (messaggio 'READY')
			CALL PRS			; Chiama la 0x28A7 (L28A7 PRS)
			POP BC				; Recupera BC dallo stack
			LD HL,PREPEXEC		; Carica in HL il valore 0x1AE8 (puntatore a PREPEXEC)
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
								;   continua con la 0x2BE4 (L2BE4 ?)

			;
			; Routine 0x2BE4 
			;
L2BE4		EX DE,HL			; Scambia DE ed HL
			LD HL,(PRGEND)		; Carica in HL da memoria puntata da (0x40F9) PRGEND
L2BE8		LD A,(DE)			; Carica in A da memoria puntata da (DE)
			LD (BC),A			; Salva A in memoria puntata da (BC)
			INC BC				; Incrementa BC
			INC DE				; Incrementa DE
			RST VCPDEHL			; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR NZ,0x2BE8		; Se diverso da zero, passa a 0x2BE8
			LD H,B				; Copia B in H
			LD L,C				; Copia C in L
			LD (PRGEND),HL		; Salva HL in memoria puntata da (0x40F9) PRGEND
			RET					; Ritorna

			;
			; Routine 0x2BF5 - CSAVE
			;
CSAVE		CALL VOUTTAP		; Chiama la 0x0284 (L0284 VOUTTAP)
			CALL EVAL			; Chiama la 0x2337 (L2337 EVAL)
			PUSH HL				; Salva HL nello stack
			CALL L2A13			; Chiama la 0x2A13 (L2A13 GTFLNM)
			LD A,0xD3			; Carica in A il valore 0xD3 
			CALL VWRTAPE		; Chiama la 0x0264 (L0264 VWRTAPE)
			CALL VWRTAPE2		; Chiama la 0x0261 (L0261 VWRTAPE2)
			LD A,(DE)			; Carica in A da memoria puntata da (DE)
			CALL VWRTAPE		; Chiama la 0x0264 (L0264 VWRTAPE)
			LD HL,(BASTXT)		; Carica in HL da memoria puntata da (0x40A4) BASTXT
			EX DE,HL			; Scambia DE ed HL
			LD HL,(PRGEND)		; Carica in HL da memoria puntata da (0x40F9) PRGEND
L2C12		LD A,(DE)			; Carica in A da memoria puntata da (DE)
			INC DE				; Incrementa DE
			CALL VWRTAPE		; Chiama la 0x0264 (L0264 VWRTAPE)
			RST VCPDEHL			; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR NZ,L2C12			; Se diverso da zero, passa a 0x2C12
			CALL DELS18			; Chiama la 0x01F5 (L01F5 DELS18)
			POP HL				; Recupera HL dallo stack
			RET					; Ritorna

			;
			; Routine 0x2C1F - CLOAD
			;
CLOAD		CALL VTPNOUT		; Chiama la 0x0293 (L0293 VTPNOUT)
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			SUB TKPRINT			; Sottrae da A il valore 0xB2 (token PRINT)
			JR Z,L2C29			; Se zero, passa a 0x2C29
			XOR A				; Azzera A
			.BYTE 0x01			; Esegue LD BC,0x232F  skip istruzioni CPL e INC HL
								;   continua con la 0x2C2B (L2C2B)
L2C29		CPL					; Complementa A
			INC HL				; Incrementa HL
L2C2B		PUSH AF				; Salva AF nello stack
			DEC HL				; Decrementa HL
			RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
			LD A,0x00			; Azzera A
			JR Z,L2C39			; Se zero, passa a 0x2C39
			CALL EVAL			; Chiama la 0x2337 (L2337 EVAL)
			CALL L2A13			; Chiama la 0x2A13 (L2A13 GTFLNM)
			LD A,(DE)			; Carica in A da memoria puntata da (DE)
L2C39		LD L,A				; Copia A in L
			POP AF				; Recupera AF dallo stack
			OR A				; Esegue OR di A
			LD H,A				; Copia A in H
			LD (FPREG),HL		; Salva HL in memoria puntata da (0x4121) FPREG
			CALL Z,CLRPTR		; Se zero, chiama la 0x1B4D (L1B4D CLRPTR)
			LD HL,(FPREG)		; Carica in HL da memoria puntata da (0x4121) FPREG
			EX DE,HL			; Scambia DE ed HL
L2C47		LD B,0x03			; Carica in B il valore 0x03
L2C49		CALL VRDTAPE		; Chiama la 0x0235 (L0235 VRDTAPE)
			SUB 0xD3			; Sottrae da A il valore 0xD3
			JR NZ,L2C47			; Se diverso da zero, passa a 0x2C47
			DJNZ L2C49			; Decrementa B, se diverso da zero passa a 0x2C49
			CALL VRDTAPE		; Chiama la 0x0235 (L0235 VRDTAPE)
			INC E				; Incrementa E
			DEC E				; Decrementa E
			JR Z,L2C5C			; Se zero, passa a 0x2C5C
			CP E				; Compara A con E
			JR NZ,L2C93			; Se diverso da zero, passa alla 0x2C93 (L2C93 VCHTAP)
L2C5C		LD HL,(BASTXT)		; Carica in HL da memoria puntata da (0x40A4) BASTXT
L2C5F		LD B,0x03			; Carica in B il valore 0x03
L2C61		CALL VRDTAPE		; Chiama la 0x0235 (L0235 VRDTAPE)
			LD E,A				; Copia A in E
			SUB (HL)			; Sottrae da A memoria puntata da (HL)
			AND D				; Esegui AND di A con D
			JR NZ,L2C8A			; Se diverso da zero, passa a 0x2C8A (L2C8A VISBAD)
			LD (HL),E			; Copia E in memoria puntata da (HL)
			CALL ENFMEM			; Chiama la 0x196C (L196C ENFMEM)
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			OR A				; Esegue OR di A
			INC HL				; Incrementa HL
			JR NZ,L2C5F			; Se diverso da zero, passa a 0x2C5F
			CALL L022C			; Chiama la 0x022C (L022C VLAMPTAPE)
			DJNZ L2C61			; Decrementa B, se diverso da zero passa a 0x2C61
			LD (PRGEND),HL		; Salva HL in memoria puntata da (0x40F9) PRGEND
			CALL DELS18			; Chiama la 0x01F5 (L01F5 DELS18)
			LD HL,MREADY		; Carica in HL il valore 0x1929 (messaggio 'READY')
			CALL PRS			; Chiama la 0x28A7 (L28A7 PRS)
			LD HL,(BASTXT)		; Carica in HL da memoria puntata da (0x40A4) BASTXT
			PUSH HL				; Salva HL nello stack
			JP PREPEXEC			; Passa alla 0x1AE8 (L1AE8 PREPEXEC)

			;
			; Routine 0x2C8A - VISBAD Visualizza messagio "BAD\r"
			;
L2C8A		LD HL,MBAD			; Carica in HL il valore 0x2CA5 (messaggio 'BAD\r')
			CALL PRS			; Chiama la 0x28A7 (L28A7 PRS)
			JP BASMAIN2			; Passa a 0x1A18 (L1A18 BASMAIN2)

			;
			; Routine 0x2C93 - VCHTAP Visualizza carattere nella prima riga
			;   Input: A carattere da visualizzare 
			;
L2C93		LD (VIDBASE+0x1E),A	; Salva A in memoria puntata da (0xEC1E video, penultimo carattere, prima riga)
L2C96		LD B,0x03			; Carica in B il valore 0x03
L2C98		CALL VRDTAPE		; Chiama la 0x0235 (L0235 VRDTAPE)
			OR A				; Esegue OR di A
			JR NZ,L2C96			; Se diverso da zero, passa a 0x2C96
			DJNZ L2C98			; Decrementa B, se diverso da zero passa a 0x2C98
			CALL L0296			; Chiama la 0x0296 (L0296 ?)
			JR L2C47			; Passa a 0x2C47 (L2C47 ?)

			; Messaggio errore cassette
			;
MBAD		.TEXT 'BAD', 0x0D, 0x00

			;
			; Routine 0x2CAA - PEEK
			;
PEEK		CALL CINT			; Chiama la 0x0A7F (L0A7F CINT)
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			JP MVAU2FPR			; Passa a 0x27F8 (L27F8 MVAU2FPR)
			
			;
			; Routine 0x2CB1 - POKE
			;
POKE		CALL GETSINT		; Chiama la 0x2B02 (L2B02 GETSINT)
			PUSH DE				; Salva DE nello stack
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','			; (carattere ',')	
			CALL GETBYT			; Chiama la 0x2B1C (L2B1C GETBYT)
			POP DE				; Get integer 0-255
			LD (DE),A			; Restore memory address
			RET					; Load it into memory

			;
			; Routine 0x2CBD - TAB
			;
TAB			CALL L2338			; Chiama la 0x2338 (L2338 EVAL1)
			CALL TSTSTR			; Chiama la 0x0AF4 (L0AF4 TSTSTR)
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ';'			; (carattere ';')
			EX DE,HL			; Scambia DE ed HL
			LD HL,(FPREG)		; Carica in HL da memoria puntata da (0x4121)
			JR L2CD3			; Passa alla 0x2CD3 (L2CD3 ?)

			;
			; Routine 0x2CCB
			;
L2CCB		LD A,(READFG)		; Carica in A da memoria puntata da (0x40DE) READFG
			OR A				; Esegue OR di A
			JR Z,L2CDD			; Se zero, passa a 0x2CDD
			POP DE				; Recupera DE dallo stack
			EX DE,HL			; Scambia DE ed HL

			;
			; Routine 0x2CD3
			;
L2CD3		PUSH HL				; Salva HL nello stack
			XOR A				; Azzera A
			LD (READFG),A		; Salva A in memoria puntata da (0x40DE) READFG
			CP D				; Compara A con D
			PUSH AF				; Salva AF nello stack
			PUSH DE				; Salva DE nello stack
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			OR B				; Esegue OR di A con B
L2CDD		JP Z,IFERR			; Se zero, passa alla 0x1E4A (L1E4A IFERR)
			INC HL				; Incrementa HL
			LD C,(HL)			; Carìca in C da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD H,(HL)			; Carìca in H da memoria puntata da (HL)
			LD L,C				; Copia C in L
			JR L2D03			; Passa alla 0x2D03 (L2D03 ?)

			;
			; Routine 0x2CE7
			;
L2CE7		LD E,B				; Copia B in E
			PUSH HL				; Salva HL nello stack
			LD C,0x02			; Carica in C il valore 0x02
L2CEB		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			INC HL				; Incrementa HL
			CP 0x25				; Compara A con il valore 0x25 (carattere '%')
			JP Z,L2E17			; Se zero, passa alla 0x2E17 (L2E17 ?)
			CP 0x20				; Compara A con il valore 0x20 (carattere ' ')
			JR NZ,L2CF9			; Se diverso da zero, passa a 0x2CF9
			INC C				; Incrementa C
			DJNZ L2CEB			; Decrementa B, se diverso da zero passa a 0x2CEB
L2CF9		POP HL				; Recupera HL dallo stack
			LD B,E				; Copia E in B
			LD A,'%'			; Carica in A il valore 0x25 (carattere '%')
L2CFD		CALL L2E49			; Chiama la 0x2E49 (L2E49 ?)
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
								;   continua con la 0x2D03 (L2D03 ?)

			;
			; Routine 0x2D03
			;
L2D03		XOR A				; Azzera A
			LD E,A				; Copia A in E
			LD D,A				; Copia A in D
L2D06		CALL L2E49			; Chiama la 0x2E49 (L2E49 ?)
			LD D,A				; Copia A in D
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			INC HL				; Incrementa HL
			CP 0x21				; Compara A con il valore 0x21 (carattere '!')
			JP Z,L2E14			; Se uguale, passa a 0x2E14 (L2E14 ?)
			CP 0x23				; Compara A con il valore 0x23 (carattere '#')
			JR Z,L2D4C			; Se uguale, passa a 0x2D4C 
			DEC B				; Decrementa B
			JP Z,L2DFE			; Se zero, passa a 0x2DFE (L2DFE ?)
			CP 0x2B				; Compara A con il valore 0x2B (carattere '"')
			LD A,0x08			; Carica in A il valore 0x08
			JR Z,L2D06			; Se uguale, passa a 0x2D06
			DEC HL				; Decrementa HL
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			INC HL				; Incrementa HL
			CP 0x2E				; Compara A con il valore 0x2E (carattere '>')
			JR Z,L2D66			; Se uguale, passa a 0x2D66
			CP 0x25				; Compara A con il valore 0x25 (carattere '%')
			JR Z,L2CE7			; Se zero, passa a 0x2CE7 (L2CE7 ?)
			CP (HL)				; Compara A con memoria puntata da (HL)
			JR NZ,L2CFD			; Se diverso, passa a 0x2CFD (L2CFD ?)
			CP 0x24				; Compara A con il valore 0x24 (carattere '$')
			JR Z,L2D45			; Se zero, passa a 0x2D45
			CP 0x2A				; Compara A con il valore 0x2A (carattere '*')
			JR NZ,L2CFD			; Se diverso, passa a 0x2CFD (L2CFD ?)
			LD A,B				; Copia B in A
			CP 0x02				; Compara A con il valore 0x02
			INC HL				; Incrementa HL
			JR C,L2D3E			; Se CY=1, passa a 0x2D3E
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			CP 0x24				; Compara A con il valore 0x24 (carattere '$')
L2D3E		LD A,0x20				; Carica in A il valore 0x20
			JR NZ,L2D49			; Se diverso, passa a 0x2D49
			DEC B				; Decrementa B
			INC E				; Incrementa E
			.BYTE 0xFE			; Esegue CP 0xAF  skip istruzione XOR A
								;   continua con la 0x2D46 (L2D46)
L2D45		XOR A				; Azzera A
L2D46		ADD A,0x10			; Somma ad A il valore 0x10
			INC HL				; Incrementa HL
L2D49		INC E				; Incrementa E
			ADD A,D				; Somma D ad A
			LD D,A				; Copia A in D
L2D4C		INC E				; Incrementa E
			LD C,0x00			; Azzera C
			DEC B				; Decrementa B
			JR Z,L2D99			; Se zero, passa a 0x2D99
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			INC HL				; Incrementa HL
			CP 0x2E				; Compara A con il valore 0x2E (carattere '.')
			JR Z,L2D70			; Se uguale, passa a 0x2D70
			CP 0x23				; Compara A con il valore 0x23 (carattere '#')
			JR Z,L2D4C			; Se uguale, passa a 0x2D4C
			CP 0x2C				; Compara A con il valore 0x2C (carattere ',')
			JR NZ,L2D7A			; Se diverso, passa a 0x2D7A
			LD A,D				; Copia D in A
			OR 0x40				; Esegue OR di A con il valore 0x40
			LD D,A				; Copia A in D
			JR L2D4C			; Passa a 0x2D4C

			;
			; Routine 0x2D66
			;
L2D66		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			CP 0x23				; Compara A con il valore 0x23 (carattere '#')
			LD A,0x2E			; Carica in A il valore 0x2E (carattere '.')
			JR NZ,L2CFD			; Se diverso, passa a 0x2CFD (L2CFD ?)
			LD C,0x01			; Carica in C il valore 0x01
			INC HL				; Incrementa HL
L2D70		INC C				; Incrementa C
			DEC B				; Decrementa B
			JR Z,L2D99			; Se zero, passa a 0x2D99
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			INC HL				; Incrementa HL
			CP 0x23				; Compara A con il valore 0x23 (carattere '#')
			JR Z,L2D70			; Se zero, passa a 0x2D70
L2D7A		PUSH DE				; Salva DE nello stack
			LD DE,L2D97			; Carica in DE il valore 0x2D97
			PUSH DE				; Salva DE nello stack
			LD D,H				; Copia H in D
			LD E,L				; Copia L in E
			CP 0x5B				; Compara A con il valore 0x5B (carattere '[')
			RET NZ				; Se diverso, ritorna
			CP (HL)				; Compara A con memoria puntata da (HL)
			RET NZ				; Se diverso, ritorna
			INC HL				; Incrementa HL
			CP (HL)				; Compara A con memoria puntata da (HL)
			RET NZ				; Se diverso, ritorna
			INC HL				; Incrementa HL
			CP (HL)				; Compara A con memoria puntata da (HL)
			RET NZ				; Se diverso, ritorna
			INC HL				; Incrementa HL
			LD A,B				; Copia B in A
			SUB 0x04			; Sottrae da A il valore 0x04
			RET C				; Se CY=1, ritorna
			POP DE				; Recupera DE dallo stack
			POP DE				; Recupera DE dallo stack
			LD B,A				; Copia A in B
			INC D				; Incrementa D
			INC HL				; Incrementa HL
			.BYTE 0xCA			; Esegue JP Z,0xD1EB (mai eseguita)  skip istruzioni EX DE,HL e POP DE
								;   continua con la 0x2D99 (L2D99)
L2D97		EX DE,HL			; Scambia DE ed HL
			POP DE				; Recupera DE dallo stack
L2D99		LD A,D				; Copia D in A
			DEC HL				; Decrementa HL
			INC E				; Incrementa E
			AND 0x08			; Esegue AND di A con il valore 0x08
			JR NZ,L2DB5			; Se diverso da zero, passa a 0x2DB5
			DEC E				; Decrementa E
			LD A,B				; Copia B in A
			OR A				; Esegue OR di A
			JR Z,L2DB5			; Se zero, passa a 0x2DB5
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			SUB 0x2D			; Sottrae da A il valore 0x2D (carattere '-')	
			JR Z,L2DB0			; Se zero, passa a 0x2DB0
			CP 0xFE				; Compara A con il valore 0xFE
			JR NZ,L2DB5			; Se diverso da zero, passa a 0x2DB5
			LD A,0x08			; Carica in A il valore 0x08
L2DB0		ADD A,0x04			; Somma ad A il valore 0x04
			ADD A,D				; Somma D ad A
			LD D,A				; Copia A in D
			DEC B				; Decrementa B
L2DB5		POP HL				; Recupera HL dallo stack
			POP AF				; Recupera AF dallo stack
			JR Z,L2E09			; Se zero, passa a 0x2E09
			PUSH BC				; Salva BC nello stack
			PUSH DE				; Salva DE nello stack
			CALL EVAL			; Chiama la 0x2337 (L2337 EVAL)
			POP DE				; Recupera DE dallo stack
			POP BC				; Recupera BC dallo stack
			PUSH BC				; Salva BC nello stack
			PUSH HL				; Salva HL nello stack
			LD B,E				; Copia E in B
			LD A,B				; Copia B in A
			ADD A,C				; Somma C ad A
			CP 0x19				; Compara A con il valore 0x19
			JP NC,IFERR			; Se CY=0, passa alla 0x1E4A (L1E4A IFERR)
			LD A,D				; Copia D in A
			OR 0x80				; Esegue OR di A con il valore 0x80
			CALL L0FBE			; Chiama la 0x0FBE (L0FBE ?)
			CALL PRS			; Chiama la 0x28A7 (L28A7 PRS)
L2DD3		POP HL				; Recupera HL dallo stack
			DEC HL				; Decrementa HL
			RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
			SCF					; CY=1
			JR Z,L2DE6			; Se zero, passa a 0x2DE6
			LD (READFG),A		; Salva A in memoria puntata da (0x40DE) READFG
			CP 0x3B				; Compara A con il valore 0x3B (carattere ';')
			JR Z,L2DE5			; Se uguale, passa a 0x2DE5
			CP 0x2C				; Compara A con il valore 0x2C (carattere ',')
			JP NZ,SNERR			; Se diverso da zero, passa a 0x1997 (L1997 SNERR)
L2DE5		RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
L2DE6		POP BC				; Recupera BC dallo stack
			EX DE,HL			; Scambia DE ed HL
			POP HL				; Recupera HL dallo stack
			PUSH HL				; Salva HL nello stack
			PUSH AF				; Salva AF nello stack
			PUSH DE				; Salva DE nello stack
			LD A,(HL)			; Carica in A da memoria puntata da (HL)	
			SUB B				; Sottrae B da A
			INC HL				; Incrementa HL
			LD C,(HL)			; Carica in C da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD H,(HL)			; Carica in H da memoria puntata da (HL)
			LD L,C				; Copia C in L
			LD D,0x00			; Azzera D
			LD E,A				; Copia A in E
			ADD HL,DE			; Somma DE ad HL
			LD A,B				; Copia B in A
			OR A				; Esegue OR di A
			JP NZ,L2D03			; Se diverso da zero, passa a 0x2D03
			JR L2E04			; Passa alla 0x2E04 (L2E04 ?)

			;
			; Routine 0x2DFE
			;		
L2DFE		CALL L2E49			; Chiama la 0x2E49 (L2E49 ?)
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
L2E04		POP HL				; Salva HL nello stack
			POP AF				; Salva AF nello stack
			JP NZ,L2CCB			; Se diverso da zero, passa a 0x2CCB (L2CCB ?)
L2E09		CALL C,PRNTCR		; Chiama la 0x20FE (L20FE ?)
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			CALL L29DD			; Chiama la 0x29DD (L29DD ?)
			POP HL				; Recupera HL dallo stack
			JP SETDEFVID		; Passa a 0x2169 (L2169 SETDEFVID)

			;
			; Routine 0x2E14
			;
L2E14		LD C,0x01			; Carica in C il valore 0x01
			.BYTE 0x3E			; Esegue LD A,0xF1  skip istruzione POP AF
								;  continua con 0x2E18 (L2E18) 
L2E17		POP AF				; Recupera AF dallo stack
L2E18		DEC B				; Decrementa B
			CALL L2E49			; Chiama la 0x2E49 (L2E49 ?)
			POP HL				; Recupera HL dallo stack
			POP AF				; Recupera AF dallo stack
			JR Z,L2E09			; Se zero, passa a 0x2E09
			PUSH BC				; Salva BC nello stack
			CALL EVAL			; Chiama la 0x2337 (L2337 EVAL)
			CALL TSTSTR			; Chiama la 0x0AF4 (L0AF4 TSTSTR)
			POP BC				; Recupera BC dallo stack
			PUSH BC				; Salva BC nello stack
			PUSH HL				; Salva HL nello stack
			LD HL,(FPREG)		; Carica in HL da memoria puntata da (0x4121)
			LD B,C				; Copia C in B
			LD C,0x00			; Azzera C
			PUSH BC				; Salva BC nello stack
			CALL L2A68			; Chiama la 0x2A68 (L2A68 ?)
			CALL PRSHL			; Chiama la 0x28AA (L28AA PRSHL)
			LD HL,(FPREG)		; Carica in HL da memoria puntata da (0x4121)
			POP AF				; Recupera AF dallo stack
			SUB (HL)			; Sottrae da A memoria puntata da (HL)
			LD B,A				; Copia A in B
			LD A,' '			; Carica in A il valore 0x20, carattere ' '
			INC B				; Incrementa B
L2E40		DEC B				; Decrementa B
			JP Z,L2DD3			; Se zero, passa alla 0x2DD3 (L2DD3 ?)
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			JR L2E40			; Passa a 0x2E40

			;
			; Routine 0x2E49
			;
L2E49		PUSH AF				; Salva AF nello stack
			LD A,D				; Copia D in A
			OR A				; Esegue OR di A
			LD A,'+'			; Carica in A il valore 0x2B, carattere '+'
			CALL NZ,OUTCHA		; Se diverso da zero, chiama la 0x032A (L032A OUTCHA)
			POP AF				; Recupera AF dallo stack
			RET					; Ritorna

			;
			; Routine 0x2E53 - ZERR  Azzera stato errore corrente
			;
ZERR		LD (CURERR),A		; Salva A in memoria puntata da (0x409A) CURERR
			LD HL,(CURERL)		; Carica in HL da memoria puntata da (0x40EA) CURERL
			OR H				; Esegue OR di A con H
			AND L				; Esegue AND di A con L
			INC A				; Incrementa A
			EX DE,HL			; Scambia DE ed HL
			RET Z				; Se zero, ritorna
			JR EDIT2			; Passa a 0x2E64 (L2E64 EDIT2)

			;
			; Routine 0x2E60 - EDIT
			;
EDIT		CALL GETVALDE		; Chiama la 0x1E4F (L1E4F GETVALDE)
			RET NZ				; Se diverso da zero, ritorna
								;   altrimenti continua con 0x2E64 (L2E64 EDIT2)

			;
			; Routine 0x2E64 - EDIT2
			;
EDIT2		POP HL				; Recupera HL dallo stack
L2E65		EX DE,HL			; Scambia DE ed HL
			LD (CUREDLN),HL		; Salva HL in memoria puntata da (0x40EC) CUREDLN
			EX DE,HL			; Scambia DE ed HL
			CALL SRCHLN			; Chiama la 0x1B2C (L1B2C SRCHLN)
			JP NC,ULERR			; Se CY=0, passa alla 0x1ED9 (L1ED9 ULERR)
			LD H,B				; Copia B in H
			LD L,C				; Copia C in L
			INC HL				; Incrementa HL
			INC HL				; Incrementa HL
			LD C,(HL)			; Carica in C da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			INC HL				; Incrementa HL
			PUSH BC				; Salva BC nello stacl
			CALL L2B7E			; Chiama la 0x2B7E (L2B7E ?)
L2E7C		POP HL				; Recupera HL dallo stack
			PUSH HL				; Salva HL nello stacl
			CALL PRNTHL			; Chiama la 0x0FAF (L0FAF PRNTHL)
			LD A,' '			; Carica in A il valore 0x20, carattere ' '
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			LD HL,(PBUFFER)		; Carica in HL da memoria puntata da (0x40A7) PBUFFER
			LD A,CHPN			; Carica in A il valore 0x0E (Tasto <PGN>)
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			PUSH HL				; Salva HL nello stacl
			LD C,0xFF			; Carica in C il valore 0xFF
L2E91		INC C				; Incrementa C
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			OR A				; Eseguer OR di A
			INC HL				; Incrementa HL
			JR NZ,L2E91			; Se diverso da zero, passa a 0x2E91 
			POP HL				; Recupera HL dallo stack
			LD B,A				; Copia A in B
			LD D,0x00			; Azzera D
L2E9B		CALL WTAKEY			; Chiama la 0x0384 (L0384 WTAKEY)
			SUB 0x30			; Sottrae da A il valore 0x30 (carattere '0')
			JR C,L2EB0			; Se CY=1, passa a 0x2EB0
			CP 0x0A				; Compara A con il valore 0x0A
			JR NC,L2EB0			; Se CY=0, passa a 0x2EB0
			LD E,A				; Copia A in E
			LD A,D				; Copia D in A
			RLCA				; Ruota A a sinistra di un bit
			RLCA				; Ruota A a sinistra di un bit
			ADD A,D				; Somma D ad A
			RLCA				; Ruota A a sinistra di un bit
			ADD A,E				; Somma E ad A
			LD D,A				; Copia A in D
			JR L2E9B			; Passa a 0x2E9B
			;
L2EB0		PUSH HL				; Salva HL nello stacl
			LD HL,0x2E99		; Carica in HL il valore 0x2E99 (???)
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			DEC D				; Decrementa D
			INC D				; Incrementa D
			JP NZ,L2EBB			; Se diverso da zero, passa a 0x2EBB
			INC D				; Incrementa D
L2EBB		CP 0xD8				; Compara A con il valore 0xD8
			JP Z,L2FD2			; Se uguale, passa a 0x2FD2
			CP 0xDD				; Compara A con il valore 0xDD
			JP Z,L2FE0			; Se uguale, passa a 0x2FE0
			CP 0xF0				; Compara A con il valore 0xFF
			JR Z,L2F0A			; Se uguale, passa a 0x2F0A
			CP 0x31				; Compara A con il valore 0x31
			JR C,L2ECF			; Se CY=1, passa a 0x2ECF
			SUB 0x20			; Sottrae da A il valore 0x20
L2ECF		CP 0x21				; Compara A con il valore 0x21
			JP Z,L2FF6			; Se uguale, passa a 0x2FF6
			CP 0x1C				; Compara A con il valore 0x1C
			JP Z,L2F40			; Se uguale, passa a 0x2F40
			CP 0x23				; Compara A con il valore 0x23 
			JR Z,L2F1C			; Se uguale, passa a 0x2F1C
			CP 0x19				; Compara A con il valore 0x19
			JP Z,L2F7D			; Se uguale, passa a 0x2F7D
			CP 0x14				; Compara A con il valore 0x14
			JP Z,L2F4A			; Se uguale, passa a 0x2F4A
			CP 0x13				; Compara A con il valore 0x13
			JP Z,L2F65			; Se uguale, passa a 0x2F65
			CP 0x15				; Compara A con il valore 0x15
			JP Z,L2FE3			; Se uguale, passa a 0x2FE3
			CP 0x28				; Compara A con il valore 0x28
			JP Z,L2F78			; Se uguale, passa a 0x2F78
			CP 0x1B				; Compara A con il valore 0x1B
			JR Z,L2F16			; Se uguale, passa a 0x2F16
			CP 0x18				; Compara A con il valore 0x18
			JP Z,L2F75			; Se uguale, passa a 0x2F75
			CP 0x11				; Compara A con il valore 0x11
			RET NZ				; Se diverso, ritorna
			POP BC				; Recupera BC dallo stack
			POP DE				; Recupera DE dallo stack
			CALL PRNTCR			; Chiama la 0x20FE (L20FE ?)
			JP L2E65			; Passa a 0x2E65
			;
L2F0A		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			OR A				; Esegue OR di A
			RET Z				; Se zero, ritorna
			INC B				; Incrementa B
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			INC HL				; Incrementa HL
			DEC D				; Decrementa D
			JR NZ,L2F0A			; Se diverso da zero, passa a 0x2F0A
			RET					; Ritorna
			;
L2F16		PUSH HL				; Salva HL nello stack
			LD HL,0x2F5F		; Carica in HL il valore 0x2F5F
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			SCF					; CY=1
L2F1C		PUSH AF				; Salva AF nello stack
			CALL WTAKEY			; Chiama la 0x0384 (L0384 WTAKEY)
			LD E,A				; Copia A in E
			POP AF				; Recupera AF dallo stack
			PUSH AF				; Salva AF nello stack
			CALL C,L2F5F		; Se CY=1, chiama la 0x2F5F (L2F5F ?)
L2F26		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			OR A				; Esegue OR di A
			JP Z,L2F3E			; Se zero, passa a 0x2F3E
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			POP AF				; Recupera AF dallo stack
			PUSH AF				; Salva AF nello stack
			CALL C,L2FA1		; Se CY=1, chiama la 0x2FA1 (L2FA1 ?)
			JR C,L2F37			; Se CY=1, passa a 0x2F37
			INC HL				; Incrementa HL
			INC B				; Incrementa B
L2F37		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			CP E				; Compara A con E
			JR NZ,L2F26			; Se diverso da zero, passa a 0x2F26
			DEC D				; Decrementa D
			JR NZ,L2F26			; Se diverso da zero, passa a 0x2F26
L2F3E		POP AF				; Recupera AF dallo stack
			RET     			; Ritorna
			;
L2F40		CALL L2B75			; Chiama la 0x2B75 (L2B75 ?)
			CALL PRNTCR			; Chiama la 0x20FE (L20FE ?)
			POP BC				; Recupera BC dallo stack
			JP L2E7C			; Passa a 0x2E7C
			;
L2F4A		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			OR A				; Esegue OR di A
			RET Z				; Se zero, ritorna
			LD A,'!'			; Carica in A il valore 0x21, carattere '!'
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
L2F52		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			OR A				; Esegue OR di A
			JR Z,L2F5F			; Se zero, passa a 0x2F5F
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			CALL L2FA1			; Chiama la 0x2FA1 (L2FA1 ?)
			DEC D				; Decrementa D
			JR NZ,L2F52			; Se diverso da zero, passa a 0x2F52
L2F5F		LD A,'!'			; Carica in A il valore 0x21, carattere '!'
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			RET     			; Ritorna
			;
L2F65		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			OR A				; Esegue OR di A
			RET Z				; Se zero, ritorna
			CALL WTAKEY			; Chiama la 0x0384 (L0384 WTAKEY)
			LD (HL),A			; Salva A in memoria puntata da (HL)
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			INC HL				; Incrementa HL
			INC B				; Incrementa B
			DEC D				; Decrementa D
			JR NZ,L2F65			; Se diverso da zero, passa a 0x2F65
			RET     			; Ritorna
			;
L2F75		LD (HL),0x00		; Azzera memoria puntata da (HL)
			LD C,B				; Copia B in C
L2F78		LD D,0xFF			; Carica in D il valore 0xFF
			CALL L2F0A			; Chiama la 0x2F0A (L2F0A ?)
L2F7D		CALL WTAKEY			; Chiama la 0x0384 (L0384 WTAKEY)
			OR A				; Esegue OR di A
			JP Z,L2F7D			; Se zero, passa a 0x2F7D
			CP 0x08				; Compara A con il valore 0x08 (Tasto BackSpace)
			JR Z,L2F92			; Se zero, passa a 0x2F92
			CP 0x0D				; Compara A con il valore 0x0D (Tasto CR)
			JP Z,L2FE0			; Se zero, passa a 0x2FE0
			CP 0x1B				; Compara A con il valore 0x1B (Tasto ESC)
			RET Z				; Se zero, ritorna
			JR NZ,L2FB0			; Se diverso da zero, passa a 0x2FB0
			;
L2F92		LD A,0x08			; Carica in A il valore 0x08, carattere BackSpace
			DEC B				; Decrementa B
			INC B				; Incrementa B
			JR Z,L2FB7			; Se zero, passa a 0x2FB7
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			DEC HL				; Decrementa HL
			DEC B				; Decrementa B
			LD DE,0x2F7D		; Carica in DE il valore 0x2F7D
			PUSH DE				; Salva DE nello stack
L2FA1		PUSH HL				; Salva HL nello stack
			DEC C				; Decrementa C
L2FA3		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			OR A				; Esegue OR di A
			SCF					; CY=1
			JP Z,L0890			; Se zero, passa a 0x0890
			INC HL				; Incrementa HL
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			DEC HL				; Decrementa HL
			LD (HL),A			; Salva A in memoria puntata da (HL)
			INC HL				; Incrementa HL
			JR L2FA3			; Passa a 
			;
L2FB0		PUSH AF				; Salva AF nello stack
			LD A,C				; Copia C in A
			CP 0xFF				; Compara A con il valore 0xFF
			JR C,L2FB9			; Se CY=1, passa a 0x2FB9
			POP AF				; Recupera AF dallo stack
L2FB7		JR L2F7D			; Passa a 0x2F7D
			;
L2FB9		SUB B				; Sottrae B da A
			INC C				; Incrementa C
			INC B				; Incrementa B
			PUSH BC				; Salva BC nello stack
			EX DE,HL			; Scambia DE ed HL
			LD L,A				; Copia A in L
			LD H,0x00			; Azzera H
			ADD HL,DE			; Somma DE ad HL
			LD B,H				; Copia H in B
			LD C,L				; Copia L in C
			INC HL				; Incrementa HL
			CALL L1958			; Chiama la 0x1958 (L1958 ?)
			POP BC				; Recupera BC dallo stack
			POP AF				; Recupera AF dallo stack
			LD (HL),A			; Salva A in memoria puntata da (HL)
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			INC HL				; Incrementa HL
			JP L2F7D			; Passa a 0x2F7D
			;
L2FD2		LD A,B				; Copia B in A
			OR A				; Esegue OR di A
			RET Z				; Se zero, ritorna
			DEC B				; Decrementa B
			DEC HL				; Decrementa HL
			LD A,CHBS			; Carica in A il valore 0x08 (carattere <BS>)
			CALL OUTCHA			; Chiama la 0x032A (L032A OUTCHA)
			DEC D				; Decrementa D
			JR NZ,L2FD2			; Se diverso da zero, passa a 0x2FD2
			RET					; Ritorna
			;
L2FE0		CALL L2B75			; Chiama la 0x2B75 (L2B75 ?)
L2FE3		CALL PRNTCR			; Chiama la 0x20FE (L20FE ?)
			POP BC				; Recupera BC dallo stack
			POP DE				; Recupera AF dallo stack
			LD A,D				; Copia D in A
			AND E				; Esegue AND di A con E
			INC A				; Incrementa A
								;   continua con 0x2FEB (L2FEB ?)

			;
			; Routine 0x2FEB 
			;
L2FEB		LD HL,(PBUFFER)		; Carica in HL da memoria puntata da (0x40A7) PBUFFER, (valore 0x41E8 => PREBUFFER+3 => BUFFER)
			DEC HL				; Decrementa HL
			RET Z				; Se zero, ritorna
			SCF					; CY=1
			INC HL				; Incrementa HL
			PUSH AF				; Salva AF nello stack
			JP L1A98			; Passa alla 0x1A98 (L1A98 ?)
			
			;
			; Routine 0x2FF6 
			;
L2FF6		POP BC				; Recupera BC dallo stack
			POP DE				; Recupera DE dallo stack
			JP BASMAIN			; Passa a 0x1A19 (L1A19 BASMAIN)

			; NOP da 0x2FFB a 0x2FFF
			;
			DEFS 0x05, 0x00

			;			
			; Tabella messaggi d'errore 
			;
ER00		.TEXT 'NEXT WITHOUT FOR', 0x00				; Cod. Err. 0x00
ER02		.TEXT 'SYNTAX ERROR', 0x00					; Cod. Err. 0x02
ER04		.TEXT 'RETURN WITHOUT GOSUB', 0x00			; Cod. Err. 0x04
ER06		.TEXT 'OUT OF DATA', 0x00					; Cod. Err. 0x06
ER08		.TEXT 'ILLEGAL FUNCTION CALL', 0x00			; Cod. Err. 0x08
ER0A		.TEXT 'OVERFLOW', 0x00						; Cod. Err. 0x0A
ER0C		.TEXT 'OUT OF MEMORY', 0x00					; Cod. Err. 0x0C
ER0E		.TEXT 'UNDEFINED LINE NUMBER', 0x00			; Cod. Err. 0x0E
ER10		.TEXT 'SUBSCRIPT OUT OF RANGE', 0x00		; Cod. Err. 0x10
ER12		.TEXT 'REDIMENSIONED ARRAY', 0x00			; Cod. Err. 0x12
ER14		.TEXT 'DIVISION BY ZERO', 0x00				; Cod. Err. 0x14
ER16		.TEXT 'ILLEGAL DIRECT', 0x00				; Cod. Err. 0x16
ER18		.TEXT 'TYPE MISMATCH', 0x00					; Cod. Err. 0x18
ER1A		.TEXT 'OUT OF STRING SPACE', 0x00			; Cod. Err. 0x1A
ER1C		.TEXT 'STRING TOO LONG', 0x00				; Cod. Err. 0x1C
ER1E		.TEXT 'STRING FOMULA TOO COMPLEX', 0x00		; Cod. Err. 0x1E
ER20		.TEXT 'CAN', 0x27, 'CONTINUE', 0x0			; Cod. Err. 0x20
ER22		.TEXT 'NO RESUME', 0x00						; Cod. Err. 0x22
ER24		.TEXT 'RESUME WITHOUT ERROR', 0x00			; Cod. Err. 0x24
ER26		.TEXT 'UNPRINTABLE ERROR', 0x00				; Cod. Err. 0x26
ER28		.TEXT 'MISSING OPERAND', 0x00				; Cod. Err. 0x28
ER2A		.TEXT 'BAD FILE DATA', 0x00					; Cod. Err. 0x2A

			;
			; Routine 0x3175 - SNDTAPE18 Invia 0x18 a registratore, spegne motori
			;
SNDTAPE18	LD A,0x18				; Carica in A il valore 0x18
			OUT (PORT_TAPED),A		; Out di A su porta 0xEF (Interfaccia cassette)
			RET     				; Ritorna

			;
			; Routine 0x317A - SETCHO  Imposta canale di output (video/tape)
			;					Imposta out video se il carattere del testo non è #
			;					altimenti input valore 1 per il tape
			;	Input: HL puntatore a testo
			;
SETCHO		LD A,(HL)				; Carica in A memoria puntata da (HL)
			SUB '#'					; Sottrae da A il valore 0x23 (carattere '#')
			LD A,0x10				; Carica in A il valore 0x10 (Out: Video)
			JR NZ,L3194				; Se diverso, passa a 0x3194
			;
			CALL GETNSINT			; Chiama la 0x2B01 (L2B01 GETNSINT)
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','				; (carattere ',')
			LD A,E					; Copia E in A
			AND D					; Esegue AND di A con D
			ADD A,0x02				; Somma ad A il valore 0x02
			JP NC,IFERR				; Se CY=0, passa alla 0x1E4A (L1E4A IFERR)
			DEC A					; Decrementa A
			LD A,0x10				; Carica in A il valore 0x10 (Out: Video)
			JR Z,L3194				; Se zero, passa a 0x3194
			LD A,0x08				; Carica in A il valore 0x08 (Out: Tape)
L3194		LD (CHNNO),A			; Salva A in memoria puntata da (0x403D) CHNNO
			RET						; Ritorna

			;
			; Routine 0x3198 - TPNOUT  Out numero tape
			;
L3198		CALL SETCHO				; Chiama la 0x317A (L317A SETCHO)
			OUT (PORT_TAPED),A		; Out di A su porta 0xEF (Interfaccia cassette)
			CALL DELAY				; Chiama la 0x31F4 (L31F4 DELAY)
			OUT (PORT_TAPED),A		; Out di A su porta 0xEF (Interfaccia cassette)
									;   continua con la 0x31A2 (L31A2 VISAST)

			;
			; Routine 0x31A2 - VISAST  Visualizza asterischi
			;
L31A2		LD A,0x2A				; Carica in A il valore 0x2A (carattere '*')
			LD (VIDBASE+0x1E),A		; Salva A in memoria puntata da (0xEC1E), su video, prima riga, penultimo carattere
			LD (VIDBASE+0x1F),A		; Salva A in memoria puntata da (0xEC1F), su video, prima riga, ultimo carattere
			RET     				; Ritorna

			;
			; Routine 0x31AB - OUTTAP  Invio di A al tape
			;  Input: A 
			;
OUTTAP		CALL SETCHO				; Chiama la 0x317A (L317A SETCHO)
			OR 0x04					; Esegue OR di A con valore 0x04 (set bit 2), RESET 4520
			OUT (PORT_TAPED),A		; Out di A su porta 0xEF (Interfaccia cassette)
			CALL DELAY				; Chiama la 0x31F4 (L31F4 DELAY)
			CALL DELAY				; Chiama la 0x31F4 (L31F4 DELAY)
			RET     				; Ritorna

			;
			; Routine 0x31B9 - LAMPTAPE  Esegue lampeggio asterisco su schermo durante gestione cassette
			;
L31B9		LD A,(VIDBASE+0x1F)		; Carica in A il valore puntato da (0xEC1F), video, prima riga, ultimo carattere
			XOR 0x0A				; Esegue XOR di A con valore 0x0A (scambia carattere 0x20 ' ' e 0x2A '*')
			LD (VIDBASE+0x1F),A		; Salva A in memoria puntata da (0xEC1F), video, prima riga, ultimo carattere
			RET						; Ritorna     

			;
			; Routine 0x31C2 - WRTAPE2  Scrittura di due byte su interfaccia cassette?
			;   Output: A carattere da scrivere
			;
WRTAPE2		CALL WRTAPE				; Chiama la 0x31C5 (L31C5 WRTAPE)
									;   continua con la 0x31C5 (L31C5 WRTAPE)

			;
			; Routine 0x31C5 - WRTAPE  Scrittura di un byte su interfaccia cassette
			;   Input: A carattere da scrivere
			;
WRTAPE		PUSH DE					; Salva DE nello stack
			PUSH AF					; Salva AF nello stack
			LD DE,0x0AD7			; Carica in DE il valore 0x0AD7 (timeout per lettura da porta)
L31CA		IN A,(PORT_TAPED)		; Input in A da porta 0xEF (Interfaccia cassette)
			BIT 3,A					; Test del bit 3 di A (Framing Error)
			JR NZ,L31DB				; Se diverso da zero, passa a 0x31DB
			DEC DE					; Decrementa DE
			LD A,D					; Copia D in A
			OR E					; Esegue OR di E con A
			JR NZ,L31CA				; Se diverso da zero, passa a 0x31CA
			POP AF					; Recupera AF dallo stack
			POP DE					; Recupera DE dallo stack
			LD A,ECOD08				; Carica in A il valore 0x08 (codice errore interfaccia cassette) 
			JR L3207				; Passa a 0x3207 (L3207 TAPERR)
L31DB		POP AF					; Recupera AF dallo stack
			OUT (PORT_TAPEI),A		; Out di A su porta 0xEE (Interfaccia dati cassette)
			POP DE					; Recupera DE dallo stack
			RET						; Ritorna   

			;
			; Routine 0x31E0 - RDTAPE  Legge byte da interfaccia cassette
			;   Output: A carattere letto
			;
RDTAPE		IN A,(PORT_TAPED)		; Input in A da porta 0xEF (Interfaccia cassette)
			BIT 4,A					; Test del bit 4 di A (External Status)
			JR Z,RDTAPE				; Se zero, passa a 0x31E0, attende
			AND 0x07				; Esegue AND di A con valore 0x07 (codice di errore interfaccia cassette) (DA OE PE)
			JR NZ,L3207				; Se diverso da zero, passa a 0x3207 (L3207 TAPERR)
			LD A,(CHNNO)			; Carica in A valore puntato da (0x403D) CHNNO
			OR 0x01					; Esegue OR di A con valore 0x01 (set bit 0)
			OUT (PORT_TAPED),A		; Out di A su porta 0xEF (Interfaccia cassette)
			IN A,(PORT_TAPEI)		; Input in A da porta 0xEE (Interfaccia dati cassette)
			RET     				; Ritorna

			;
			; Routine 0x31F4 - DELAY Ritardo (contatori 0x64 x 0x1046)
			;
DELAY		PUSH AF					; Salva AF nello stack
			PUSH BC					; Salva BC nello stack
			PUSH HL					; Salva HL nello stack
			LD B,0x64				; Carica in B il valore 0x64 (ritardo)
L31F9		LD HL,0x1046			; Carica in HL il valore 0x1046 (ritardo)
L31FC		DEC HL					; Decrementa HL
			LD A,H					; Copia H in A
			OR L					; Esegue OR di A con L
			JR NZ,L31FC				; Se HL diverso da zero, passa a 0x31FC
			DJNZ L31F9				; Decrementa B, se diverso da zero passa a 0x31F9
			POP HL					; Recupera HL dallo stack
			POP BC					; Recupera BC dallo stack
			POP AF					; Recupera AF dallo stack
			RET     				; Ritorna

			;
			; Routine 0x3207 - TAPERR Visualizza messaggio con numero errore interfaccia cassetta
			;   Input: A codice errore
			;
L3207		LD HL,MCEN				; Carica in HL il valore 0x321C (messaggio 'CASSETTE ERROR NUMBER ')
			PUSH AF					; Salva AF nello stack
			CALL PRS				; Chiama la 0x28A7 (L28A7 PRS)
			POP AF					; Recupera AF dallo stack
			ADD A,'0'				; Somma ad A il valore 0x30 (carattere '0', converte in ASCII codice errore)
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
			LD A,CHCR				; Carica in A il valore 0x0D (carattere <CR>)
			CALL OUTCHA				; Chiama la 0x032A (L032A OUTCHA)
			JP BASMAIN2				; Passa a 0x1A18 (L1A18 BASMAIN2)

			; Messaggio
MCEN		.TEXT 'CASSETTE ERROR NUMBER ', 0x00

			; 
			; Routine 0x3233 - DORSP  Esegue operazioni su RAM video di RESET/SET/POINT
			;   Input: A valore letto da video
			;
L3233		JR Z,L324E				; Se zero, passa a 0x324E
			JP M,L3243				; Se negativo, passa a 0x3243
			LD IX,TABSR2			; Carica in IX il valore 0x326E (TABSR1)
			ADD IX,BC				; Somma BC ad IX
			AND (IX+0x00)			; Esegue AND di A con memoria puntata da (IX)
			JR L3261				; Passa a 0x3261 (L3261 ?)
			;
L3243		LD IX,TABSR1			; Carica in IX il valore 0x3268 (TABSR1)
			ADD IX,BC				; Somma BC ad IX
			OR (IX+0x00)			; Esegue OR di A con memoria puntata da (IX)
			JR L3261				; Passa a 0x3261 (L3261 ?)
			;
L324E		LD IX,TABSR1			; Carica in IX il valore 0x3268 (TABSR1)
			ADD IX,BC				; Somma BC ad IX
			AND (IX+0x00)			; Esegue AND di A con memoria puntata da (IX)
			ADD A,0xFF				; Somma ad A il valore 0xFF
			SBC A,A					; Sottrae A da A
			PUSH HL					; Salva HL nello stack
			CALL MVAS2FPR			; Chiama la 0x098D (L098D MVAS2FPR)
			POP HL					; Recupera HL dallo stack
			JR L3264				; Passa a 0x3264 (L3264 ?)
			;
L3261		CALL OUTCHVD			; Chiama la 0x044E (L044E OUTCHVD)
L3264		POP HL					; Recupera HL dallo stack
			RST VCKCHAR				; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ')'				; (carattere ')')
			RET						; Ritorna

			; Tabella per RESET/SET
			;
TABSR1		.BYTE 0x20, 0x10, 0x08, 0x04, 0x02, 0x01
TABSR2		.BYTE 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0XFE

			; 
			; Routine 0x3274
			;
L3274 		LD A,(TYPE)			; Carica in A da memoria puntata da (0x40AF) TYPE
			DEC A				; Decrementa A
			DEC A				; Decrementa A
			DEC A				; Decrementa A
			OR A				; Esegue OR di A
			SCF					; CY=1
			JP Z,L32E0			; Se zero, passa alla 0x32E0 (L32E0 ?) (Tipo Stringa)
			LD C,(HL)			; Carica in C da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			PUSH BC				; Salva BC nello stack
			JP M,L329D			; Se negativo, passa a 0x329D
			INC HL				; Incrementa HL
			LD C,(HL)			; Carica in C da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			PUSH BC				; Salva BC nello stack
			JP PO,L329D			; Se po, passa a 0x329D
			INC HL				; Incrementa HL
			JR C,L3294			; Se CY=1, passa a 0x3294
			LD HL,TDBL1			; Carica in HL il valore 0x411D (puntatore a TDBL1)
L3294		LD C,(HL)			; Carica in C da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			INC HL				; Incrementa HL
			PUSH BC				; Salva BC nello stack
			LD C,(HL)			; Carica in C da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			PUSH BC				; Salva BC nello stack
L329D		JP C,L32EA			; Se CY=1, passa alla 0x32EA (L32EA ?)
								;   altrimenti continua con la 0x32A0 (L32A0 CHEKFN)
			
			;
			; Routine 0x32A0 - CHEKFN
			;
L32A0		RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE TKFN			; (token FN)
			LD A,0x80			; Carica in A il valore 0x80
			LD (FORFLG),A		; Salva A in memoria puntata da (0x40DC) FORFLG
			OR (HL)				; Esegue OR di A con memoria puntata da (HL)
			LD B,A				; Copia A in B
			JP L2612			; Passa a 0x2612 (L2612 ?)

			;
			; Routine 0x32AC - FN
			;
FN	 		CALL L32A0			; Chiama la 0x32A0 (L32A0 CHEKFN)
			LD A,(TYPE)			; Carica in A memoria puntata da (0x40AF) TYPE
			OR A				; Esegue OR di A
			PUSH AF				; Salva AF nello stack
			LD (NXTOPR),HL		; Salva HL in memoria puntata da (0x40F3) NXTOPR
			EX DE,HL			; Scmabia DE ed HL
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD H,(HL)			; Carica in H da memoria puntata da (HL)
			LD L,A				; Copia A in L
			OR H				; Esegue OR di A con H
			JP Z,ER2E			; Se zero, passa a 0x33D8 (L33D8 ER2E)
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			CP '('				; Compara A il valore 0x28 (carattere '(')
			JP NZ,L3313			; Se diverso, passa a 0x3313 (L3313 ?)
			RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
			LD (CUROPR),HL		; Salva HL in memoria puntata da (0x40D8) CUROPR
			JR L32CE			; Passa a 0x32CE (L32CE ?)

			;
			; Routine 0x32CC
			;
L32CC		RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','			; (carattere ',')	
L32CE		LD C,0x04			; Carica in C il valore 0x04, test per 4 livelli di stack
			CALL CHKSTK			; Chiama la 0x1963 (L1963 CHKSTK)
			LD A,0x80			; Carica in A il valore 0x80
			LD (FORFLG),A		; Salva A in memoria puntata da (0x40DC)
			CALL GETVAR			; Chiama la 0x260D (L260D GETVAR)
			EX DE,HL			; Scmabia DE ed HL
			SCF					; CY=1
			JP L3274			; Passa alla 0x3274 (L3274 ?)

			;
			; Routine 0x32E0
			;
L32E0		JP NC,L2423			; Se CY=0, passa a 0x2423 (L2423 ?)
			PUSH DE				; Salva DE nello stack
			EX DE,HL			; Scambia DE ed HL
			CALL L2888			; Chiama la 0x2888 (L2888 ?)
			POP DE				; Recupera DE dallo stack
			XOR A				; Azzera A
								;   continua con la 0x32EA (L32EA ?)

			;
			; Routine 0x32EA
			;
L32EA		PUSH HL				; Salva HL nello stack
			PUSH AF				; Salva AF nello stack
			EX DE,HL			; Scambia DE ed HL
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			CP 0x29				; Compara A con il valore 0x29
			JR NZ,L32CC			; Se diverso da zero, passa a 0x32CC (L32CC ?)
			LD HL,(NXTOPR)		; Carica in HL da memoria puntata da (0x40F3) NXTOPR
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE '('			; (carattere '(')
			PUSH HL				; Salva HL nello stack
			LD HL,(CUROPR)		; Carica in HL da memoria puntata da (0x40D8) CUROPR
L32FB		CALL GETVAR			; Chiama la 0x260D (L260D GETVAR)
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			CALL L1F2B			; Chiama la 0x1F2B (L1F2B ?)
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			CP 0x29				; Compara A con il valore 0x29
			JR Z,L330E			; Se zero, passa a 0x330E (L330E ?)
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','			; (carattere ',')
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','			; (carattere ',')
			JR L32FB			; Passa a 0x32FB (L32FB ?)
			;
L330E		RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ')'			; (Carattere ')')
			.BYTE 0x3E			; Esegue LD A,0xD5  skip istruzione PUSH DE
								;  continua con la 0x3314 (L3314)
L3313		PUSH DE				; Salva DE nello stack
L3314		RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE TKEQUAL		; (Token =)
			CALL EVAL			; Chiama la 0x2337 (L2337 EVAL)
			DEC HL				; Decrementa HL
			RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
			JP NZ,SNERR			; Se diverso da zero, passa a 0x1997 (L1997 SNERR)
			RST VGETTYPE		; Chiama la RST 0x20 (L0020 VGETTYPE)
			JR Z,L3350			; Se zero, passa a 0x3350
L3321		POP DE				; Recupera DE dallo stack
L3322		POP AF				; Recupera AF dallo stack
			JR Z,L3364			; Se zero, passa a 0x3364
			JR NC,L3343			; Se CY=0, passa a 0x3343
			POP HL				; Recupera HL dallo stack
			POP BC				; Recupera BC dallo stack
			LD (HL),B			; Salva B in memoria puntata da (HL)
			DEC HL				; Decrementa HL
			LD (HL),C			; Salva C in memoria puntata da (HL)
			JP M,L3322			; Se negativo, passa a 0x3322
			DEC HL				; Decrementa HL
			POP BC				; Recupera BC dallo stack
			LD (HL),B			; Salva B in memoria puntata da (HL)
			DEC HL				; Decrementa HL
			LD (HL),C			; Salva C in memoria puntata da (HL)
			JP PO,L3322			; Se po, passa a 0x3322
			DEC HL				; Decrementa HL
			POP BC				; Recupera BC dallo stack
			LD (HL),B			; Salva B in memoria puntata da (HL)
			DEC HL				; Decrementa HL		
			LD (HL),C			; Salva C in memoria puntata da (HL)
			DEC HL				; Decrementa HL
			POP BC				; Recupera BC dallo stack
			LD (HL),B			; Salva B in memoria puntata da (HL)
			DEC HL				; Decrementa HL
			LD (HL),C			; Salva C in memoria puntata da (HL)
			JR L3322			; Passa a 0x3322
			;
L3343		PUSH DE				; Salva DE nello stack
			PUSH AF				; Salva AF nello stack
			RST VGETTYPE		; Chiama la RST 0x20 (L0020 VGETTYPE)
			LD DE,0x40D3		; Carica in DE il valore 0x40D3
			CALL Z,L2888		; Se zero, passa a 0x2888 (L2888 ?)
			POP AF				; Recupera AF dallo stack
			JP L281A			; Passa alla 0x281A (0x281A ?)
			;
L3350		LD HL,(TMSTPT)		; Carica in HL da memoria puntata da (0x40B3) TMSTPT
			EX DE,HL			; Scambia DE ed HL
			LD HL,(FPREG)		; Carica in HL da memoria puntata da (0x4021)
			RST VCPDEHL			; Chiama la RST 0x18 (L0018 VCPDEHL)
			JR C,L335F			; Se CY=1, passa a 0x335F
			CALL L2843			; Chiama la 0x2843 (L2843 ?)
			JR L3321			; Passa a 0x3321
			;
L335F		POP DE				; Recupera DE dallo stack
			LD HL,0x40D3		; Carica in HL il valore 0x40D3
			PUSH HL				; Salva HL nello stack
L3364		CALL L29F5			; Chiama la 0x29F5 (L29F5 ?)
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			LD (TMSTPT),HL		; Salva HL in memoria puntata da (0x40B3) TMSTPT
			POP HL				; Recupera HL dallo stack
			LD (HL),A			; Salva A in memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD (HL),C			; Salva C in memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD (HL),B			; Salva B in memoria puntata da (HL)
			JR L3322			; Passa a 0x3322

			;
			; Routine 0x3373 - DEF
			;
DEF			CP TKUSR			; Compara A con il valore 0xC1 (Token USR)
			JR Z,L33C9			; Se zero, passa alla 0x33C9 (L33C9 ?)
			CALL L32A0			; Chiama la 0x32A0 (L32A0 CHEKFN)
			CALL L2828			; Chiama la 0x2828 (L2828 ?)
			EX DE,HL			; Scambia DE ed HL
			LD (HL),E			; Salva E in memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD (HL),D			; Salva D in memoria puntata da (HL)
			EX DE,HL			; Scambia DE ed HL
			LD A,(HL)			; Carica in A da memoria puntata (HL)
			CP 0x28				; Compara A con il valore 0x28 (carattere '(')
			JP NZ,DATA			; Se diverso da zero, passa alla 0x1F05 (L1F05 DATA)
			RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
L3389		CALL GETVAR			; Chiama la 0x260D (L260D GETVAR)
			LD A,(HL)			; Carica in A da memoria puntata (HL)
			CP 0x29				; Compara A con il valore 0x29 (carattere ')')
			JP Z,DATA			; Se zero, passa alla 0x1F05 (L1F05 DATA)
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','			; (carattere ',')
			JP L3389			; Passa a 0x3389

			;
			; Routine 0x3397
			;
L3397		POP AF				; Recupera AF dallo stack
			CALL L33B7			; Chiama la 0x33B7 (L33B7 ?)
			PUSH DE				; Salva DE nello stack
			CALL L252C			; Chiama la 0x25C2 (L25C2 ?)
			EX (SP),HL			; Scambia HL e memoria puntata da (SP)
			LD C,(HL)			; Carica in C da memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			LD HL,0x26E7		; Carica in HL il valore 0x26E7
			PUSH HL				; Salva HL nello stack
			PUSH BC				; Salva BC nello stack
			LD A,(TYPE)			; Carica in A da memoria puntata da (0x40AF) TYPE
			PUSH AF				; Salva AF nello stack
			CP 0x03				; Compara A con il valore 0x03
			CALL Z,L29DA		; Se uguale, chiama la 0x29DA (L29DA GSTRCU)
			POP AF				; Recupera AF dallo stack
			EX DE,HL			; Scambia DE ed HL
			LD HL,FPREG			; Carica in HL il valore 0x4121 (puntatore a FPREG)
			RET					; Ritorna

			;
			; Routine 0x33B7
			;
L33B7		RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
			LD BC,0x0000		; Azzera BC
			JR NC,L33C2			; Se CY=0, passa alla 0x332C (L332C ?)
			SUB 0x30			; Sottrae da A il valore 0x30 (carattere '0')
			RLA					; Ruota A a sinistra di 1 bit
			LD C,A				; Copia A in C
			RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
L33C2		EX DE,HL			; Scambia DE ed HL
			LD HL,L4152			; Carica in HL il valore 0x4152
			ADD HL,BC			; Somma BC ad HL
			EX DE,HL			; Scambia DE ed HL
			RET					; Ritorna

			;
			; Routine 0x33C9
			;
L33C9		CALL L33B7			; Chiama la 0x33B7 (L33B7 ?)
			PUSH DE				; Salva DE nello stack
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE TKEQUAL		; (Token =)
			CALL GETSINT		; Chiama la 0x2B02 (L2B02 GETSINT)
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			LD (HL),E			; Salva E con memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD (HL),D			; Salva D con memoria puntata da (HL)
			POP HL				; Recupera HL dallo stack
			RET					; Ritorna

			;
			; Routine 0x33D8 - ER2E - Errore 0x2E  Codice errore non usato (bug?)
			;
ER2E		LD E,0x2E			; Carica in E il valore 0x2E (codice errore 0x2E bug?)
			JP MSGERR			; Passa alla 0x19A2 (L19A2 MSGERR)

			;
			; Routine 0x33DD - INSTR
			;
INSTR		RST VGETCH			; Chiama la RST 0x10 (L0010 VGETCH)
			CALL L2335			; Chiama la 0x2335 (L2335 ?)
			RST VGETTYPE		; Chiama la RST 0x20 (L0020 VGETTYPE)
			LD A,0x01			; Carica in A il valore 0x01
			PUSH AF				; Salva AF nello stack
			JR Z,L33F8			; Se zero, chiama la 0x33F8 (L33F8 ?)
			POP AF				; Recupera AF dallo stack
			CALL L2B1F			; Chiama la 0x2B1F (L2B1F ?)
			OR A				; Esegue OR di A
			JP Z,IFERR			; Se zero, passa alla 0x1E4A (L1E4A IFERR)
			PUSH AF				; Salva AF nello stack
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','			; (carattere ',')
			CALL EVAL			; Chiama la 0x2337 (L2337 EVAL)
			CALL TSTSTR			; Chiama la 0x0AF4 (L0AF4 TSTSTR)
L33F8		RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ','			; (carattere ',')
			PUSH HL				; Salva HL nello stack
			LD HL,(FPREG)		; Carica HL da memoria puntata da (0x4121) FPREG
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			CALL EVAL			; Chiama la 0x2337 (L2337 EVAL)
			RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)
			.BYTE ')'			; (carattere ')')
			PUSH HL				; Salva HL nello stack
			CALL L29D7			; Chiama la 0x29D7 (L29D7 GETSTR)
			EX DE,HL			; Scambia DE ed HL
			POP BC				; Recupera BC dallo stack
			POP HL				; Recupera HL dallo stack
			POP AF				; Recupera AF dallo stack
			PUSH BC				; Salva BC nello stack
			LD BC,0x26E7		; Chiama la 0x26E7 (L26E7 ?)
			PUSH BC				; Salva BC nello stack
			LD BC,MVAU2FPR		; Carica in BC il valore 0x27F8 (Punta a L27F8 MVAU2FPR)
			PUSH BC				; Salva BC nello stack
			PUSH AF				; Salva AF nello stack
			PUSH DE				; Salva DE nello stack
			CALL L29DD			; Chiama la 0x29DD (L29DD ?)
			POP DE				; Recupera DE dallo stack
			POP AF				; Recupera AF dallo stack
			LD B,A				; Copia A in B
			DEC A				; Decrementa A
			LD C,A				; Copia A in C
			CP (HL)				; Compara A con memoria puntata da (HL)
			LD A,0x00			; Azzera A
			RET NC				; Se CY=0, ritorna
			LD A,(HL)			; Carica in A memoria puntata da (HL)
			OR A				; Esegue OR di A
			RET Z				; Se zero, ritorna
			LD A,(DE)			; Carica in A memoria puntata da (DE)
			OR A				; Esegue OR di A
			LD A,B				; Copia B in A
			RET Z				; Se zero, ritorna
			LD A,(HL)			; Carica in A memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD B,(HL)			; Carica in B memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD H,(HL)			; Carica in H memoria puntata da (HL)
			LD L,B				; Copia B in L
			LD B,0x00			; Azzera B
			ADD HL,BC			; Somma BC ad HL
			SUB C				; Sottrae C da A
			LD B,A				; Copia A in B
			PUSH BC				; Salva BC nello stack		
			PUSH DE				; Salva DE nello stack
			EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			LD C,(HL)			; Carica in C memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD E,(HL)			; Carica in E memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD D,(HL)			; Carica in D memoria puntata da (HL)
			POP HL				; Recupera HL dallo stack
L343E		PUSH HL				; Salva HL nello stack
			PUSH DE				; Salva DE nello stack
			PUSH BC				; Salva BC nello stack
L3441		LD A,(DE)			; Carica in A memoria puntata da (DE)
			CP (HL)				; Compara A con memoria puntata da (HL)
			JR NZ,L345C			; Se diverso, passa a 0x345C
			INC DE				; Incrementa DE
			DEC C				; Decrementa C
			JR Z,L3453			; Se zero, passa a 0x3453
			INC HL				; Incrementa HL
			DEC B				; Decrementa B
			JR NZ,L3441			; Se diverso da zero, passa a 0x3441
			POP DE				; Recupera DE dallo stack
			POP DE				; Recupera DE dallo stack
			POP BC				; Recupera BC dallo stack
L3450		POP DE				; Recupera DE dallo stack
			XOR A				; Azzera A
			RET					; Ritorna
L3453		POP HL				; Recupera HL dallo stack
			POP DE				; Recupera DE dallo stack
			POP DE				; Recupera DE dallo stack
			POP BC				; Recupera BC dallo stack
			LD A,B				; Copia B in A
			SUB H				; Sottrae H da A
			ADD A,C				; Somma C ad A
			INC A				; Incrementa A
			RET					; Ritorna
L345C		POP BC				; Recupera BC dallo stack
			POP DE				; Recupera DE dallo stack
			POP HL				; Recupera HL dallo stack
			INC HL				; Incrementa HL
			DEC B				; Decrementa B
			JR Z,L3450			; Se zero, passa a 0x3450
			JR L343E			; Passa a 0x343E

			;
			; Routine 0x3465 - LINE
			;
LINE		RST VCKCHAR			; Chiama la RST 0x08 (L0008 VCKCHAR)			
			.BYTE TKINPUT		; (Token INPUT) (per istruzione LINE INPUT)
			CP '#'				; Compara A con il valore 0x23 (carattere '#')
			JP Z,SNERR			; Se uguale, passa a a 0x1997 (L1997 SNERR)
			CALL L21CD			; Chiama la 0x21CD (L21CD ?)
			CALL GETVAR			; Chiama la 0x260D (L260D GETVAR)
			CALL TSTSTR			; Chiama la 0x0AF4 (L0AF4 TSTSTR)
			PUSH DE				; Salva DE nello stack
			PUSH HL				; Salva HL nello stack
			CALL GETLINE		; Chiama la 0x0361 (L0361 GETLINE)
			POP DE				; Recupera DE dallo stack
			POP BC				; Recupera BC dallo stack
			JP C,INPBRK			; Se CY=1, passa a 0x1DBE (L1DBE INPBRK)
			PUSH BC				; Salva BC nello stack
			PUSH DE				; Salva DE nello stack
			LD B,0x00			; Azzera B
			CALL L2868			; Chiama la 0x2868 (L2868 ?)
			POP HL				; Recupera HL dallo stack
			XOR A				; Azzera A
			JP L1F32			; Passa a 0x1F32 (L1F32 ?)

			;
			; Routine 0x348B - BOOT  Passa esecuzione all'indirizzo 0xF000
			;
BOOT		LD HL,ROMF000		; Carica in HL il valore 0xF000 (ROMF000)
			PUSH HL				; Salva HL nello stack
			LD HL,0x00D3		; Carica in HL il valore 0x00D3 (opcode OUT (0x00),A)
			LD (L4000),HL		; Salva HL in memoria puntata da (0x4000)
			LD A,0xC9			; Carica in A il valore 0x0C9 (opcode RET)
			LD (L4000+2),A		; Salva A in memoria puntata da (0x4002)
			LD A,0x00			; Azzera A
			JP L4000			; Passa a 0x4000, esegue OUT (0x00),A poi azzera A e passa a ROMF000

			;
			; Routine 0x349F - SYSDAT	Comando D di SYSTEM
			;							D ind1,ind2  
			;							Visualizza un'area di memoria
			;							dall'indirizzo ind1 (hex) all'indirizzo ind2 (hex)
			;
SYSDAT		CALL L3651			; Chiama la 0x3651 (L3651 GETV1V2)
L34A2		CALL L361D			; Chiama la 0x361D (L361D VSWSHL)
			LD A,L				; Copia L in A
			CALL L34E4			; Chiama la 0x34E4 (L34E4 ?)
			PUSH HL				; Salva HL nello stack
L34AA		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			CALL VSHXBY			; Chiama la 0x3608 (L3608 VSHXBY)
			CALL INCHLCMPDE		; Chiama la 0x36D1 (L36D1 INCHLCMPDE)
			JR C,L34DD			; Se CY=1, passa a 0x34DD
			CALL VISHCPRSP		; Chiama la 0x3620 (L3620 VISHCPRSP)
			LD A,L				; Copia L in A
			AND 0x0F			; Esegue AND di A con il valore 0x0F
			JR NZ,L34AA			; Se diverso da zero, passa a 0x34AA
L34BB		POP HL				; Recupera HL dallo stack
			LD A,L				; Copia L in A
			AND 0x0F			; Esegue AND di A con il valore 0x0F
			CALL L34E9			; Chiama la 0x34E9 (L34E9 ?)
L34C2		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			AND 0x7F			; Esegue AND di A con il valore 0x7F
			LD C,A				; Copia A in C
			CP 0x20				; Compara A con il valore 0x20
			JR C,L34CE			; Se CY=1, passa a 0x34CE
			CP 0x7E				; Compara A con il valore 0x7E
			JR C,L34D0			; Se CY=1, passa a 0x34D0
L34CE		LD C,0x2E			; Carica in C il valore 0x2E (carattere '.')
L34D0		CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			CALL L36DE			; Chiama la 0x36DE (L36DE ?)
			LD A,L				; Copia L in A
			AND 0x0F			; Esegue AND di A con il valore 0x0F
			JR NZ,L34C2			; Se diverso da zero, passa a 0x34C2
			JR L34A2			; Passa a 0x34A2
L34DD		SUB 0x0E			; Sottrae da A il valore 0x0E
			CALL L34E4			; Chiama la 0x34E4 (L34E4 ?)
			JR L34BB			; Passa a 0x34BB
L34E4		AND 0x0F			; Esegue AND di A con il valore 0x0F
			LD B,A				; Copia A in B
			ADD A,A				; Raddoppia A
			ADD A,B				; Somma B ad A
L34E9		LD B,A				; Copia A in B
			INC B				; Incrementa B
L34EB		CALL VISHCPRSP		; Chiama la 0x3620 (L3620 VISHCPRSP)
			DJNZ L34EB			; Decrementa B, se diverso da zero passa a 0x34EB
			RET					; Ritorna

			;
			; Routine 0x34F1 - SYSGO	Comando G di SYSTEM
			;							G
			;							Esegue il codice a partire dall'indirizzo del Program Counter
			;							G ind
			;							Esegue il codice a partire dall'indirizzo ind (hex)
			;							G ind1,ind2
			;							Esegue il codice a partire 
			;							dall'indirizzo ind1 (hex) e termina l'esecuzione all'indirizzo ind2 (hex)
			;
SYSGO		LD IX,IXTMP			; Carica in IX il valore 0x4181 (puntatore a IXTMP)
			XOR A				; Azzera A
			LD (IX+0x06),A		; Salva A in memoria puntata da (IX+0x06)
			CALL WKSPCMCR		; Chiama la 0x3702 (L3702 WKSPCMCR)
			JR C,L3539			; Se CY=1, passa a 0x3539 (comando senza parametri)
			JR Z,L350C			; Se zero, passa a 0x350C
			CALL GETIND			; Chiama la 0x3668 (L3668 GETIND)
			POP HL				; Recupera HL dallo stack (parametro del comando G)
			LD (TMPRAD),HL		; Salva HL in memoria puntata da (0x4171) TMPRAD (indirizzo esecuzione)
			LD A,C				; Copia C in A
			CP 0x0D				; Compara A con il valore 0x0D
			JR Z,L3539			; Se zero, passa a 0x3539
L350C		XOR A				; Azzera A
L350D		PUSH AF				; Salva AF nello stack
			LD B,0x01			; Carica in B il valore 0x01
			CALL SYSGETID		; Chiama la 0x3673 (L3673 SYSGETID)
			POP HL				; Recupera HL dallo stack (parametro del comando G)
			LD (IX+0x00),L		; Salva L in memoria puntata da (IX)
			INC IX				; Incrementa IX
			LD (IX+0x00),H		; Salva H in memoria puntata da (IX)
			INC IX				; Incrementa IX
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			LD (IX+0x00),A		; Salva A in memoria puntata da (IX)
			INC IX				; Incrementa IX
			LD (HL),0xEF		; Salva il valore 0xEF in memoria puntata da (HL)
			LD A,C				; Copia C in A
			CP CHCR				; Compara A con il valore 0x0D (carattere <CR>)
			JR Z,L3534			; Se uguale, passa a 0x3534
			POP AF				; Recupera AF dallo stack
			INC A				; Incrementa A
			CP 0x02				; Compara A con il valore 0x02 (numero parametri)
			JR NZ,L350D			; Se diverso da zero, passa a 0x350D, ripete input parametri
			JP MONPPT			; Passa alla 0x3692 (L3692 MONPPT)
			;
L3534		POP AF				; Recupera AF dallo stack
			INC A				; Incrementa A
			LD (ATMP),A			; Salva A in memoria puntata da (0x4187) ATMP, numero parametri
								;
								; Esegue comando G
L3539		LD SP,SPINI			; Carica in SP il valore 0x4167 (SPINI)
			POP AF				; Recupera AF dallo stack
			POP BC				; Recupera BC dallo stack
			POP DE				; Recupera DE dallo stack
			POP HL				; Recupera HL dallo stack
			INC SP				; Incrementa SP
			INC SP				; Incrementa SP
			INC SP				; Incrementa SP
			INC SP				; Incrementa SP
			EX AF,AF'			; Scambia AF con AF'
			POP AF				; Recupera AF dallo stack
			EX AF,AF'			; Scambia AF con AF'
			EXX					; Scambia tutti i registri
			POP BC				; Recupera BC dallo stack
			POP DE				; Recupera DE dallo stack
			POP HL				; Recupera HL dallo stack
			EXX					; Scambia tutti i registri
			POP IX				; Recupera IX dallo stack
			LD SP,(TMSPSYS)		; Carica in SP da memoria puntata da (0x416F) TMSPSYS
			LD IY,(TMPRAD)		; Carica in IY da memoria puntata da (0x4171) TMPRAD
			PUSH IY				; Salva IY nello stack (indirizzo esecuzione G)
			LD IY,(UNK07)		; Carica in IY da memoria puntata da (0x417D) UNK07
			RET					; Ritorna (passa all'inidirizzo di esecuzione G)

			;
			; Routine 0x355D - ENVECSYS  Entry point per RST 0x28 (L400C VECSYS)
			;
ENVECSYS	LD (UNK07),IY		; Salva IY in memoria puntata da (0x417D) UNK07
			POP IY				; Recupera IY dallo stack
			DEC IY				; Decrementa iY
			LD (TMPRAD),IY		; Salva IY in memoria puntata da (0x4171) TMPRAD
			LD (TMSPSYS),SP		; Salva SP in memoria puntata da (0x416F) TMSPSYS
			LD SP,UNK07			; Carica in SP il valore 0x417D (puntatore a UNK07)
			PUSH IX				; Salva IX nello stack
			EXX					; Scambia tutti i registri
			PUSH HL				; Salva HL nello stack
			PUSH DE				; Salva DE nello stack
			PUSH BC				; Salva BC nello stack
			EXX					; Scambia tutti i registri
			EX AF,AF'			; Scambia AF con AF'
			PUSH AF				; Salva AF nello stack
			EX AF,AF'			; Scambia AF con AF'
			DEC SP				; Decrementa SP
			DEC SP				; Decrementa SP
			DEC SP				; Decrementa SP
			DEC SP				; Decrementa SP
			PUSH HL				; Salva HL nello stack
			PUSH DE				; Salva DE nello stack
			PUSH BC				; Salva BC nello stack
			PUSH AF				; Salva AF nello stack
			LD A,(ATMP)			; Carica in A da memoria puntata da (0x4187) ATMP
			OR A				; Esegue OR di A
			JR Z,L359A			; Se zero, passa a 0x359A
			LD B,A				; Copia A in B
			LD HL,(IXTMP)		; Carica in HL da memoria puntata da (0x4181) IXTMP
			LD A,(CONST00A)		; Carica in A da memoria puntata da (0x4183) CONST00A
			LD (HL),A			; Salva A in memoria puntata da (HL)
			DEC B				; Decrementa B
			JR Z,L359A			; Se zero, passa a 0x359A
			LD HL,(CONST00HL)	; Carica in HL da memoria puntata da (0x4184) CONST00HL
			LD A,(CONST00A2)	; Carica in A da memoria puntata da (0x4186) CONST00A2
			LD (HL),A			; Salva A in memoria puntata da (HL)
L359A		LD SP,(SPTMP2)		; Carica in SP da memoria puntata da (0x417F) SPTMP2
			CALL MONVCR			; Chiama la 0x3656 (L3656 MONVCR)
			LD C,0x23			; Carica in C il valore 0x23 (carattere '#')
			CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			LD HL,(TMPRAD)		; Carica in HL da memoria puntata da (0x4171) TMPRAD
			CALL VSWOHL			; Chiama la 0x3603 (L3603 VSWOHL)
			JP SYSMNU			; Passa a 0x02DE (L02DE SYSMNU)

			;
			; Routine 0x35AF - SYSINP	Comando I di SYSTEM
			;							I ind
			;							Esegue l'input dalla porta ind (hex)
			;							di un byte mostrato in binario
			;
SYSINP		CALL L3671			; Chiama la 0x3671 (L3671 SYSGETI)
			POP BC				; Recupera BC dallo stack
			IN E,(C)			; Input in E da porta (C)
			JP L36A0			; Passa alla 0x36A0 (L36A0 VISBIT)
			
			;
			; Routine 0x35B8 - SYSOUT	Comando O di SYSTEM
			;							O ind,dat
			;							Esegue l'output sulla porta ind (hex) del dato dat (hex)
			;
SYSOUT		CALL SYSGETID		; Chiama la 0x3673 (L3673 SYSGETID)
			POP DE				; Recupera DE dallo stack
			POP BC				; Recupera BC dallo stack
			OUT (C),E			; Out di E su porta (C)
			RET					; Ritorna     

			;
			; Routine 0x35C0 - SYSMOVE  Comando M di SYSTEM
			;							M ind1,ind2,ind3
			;							Muove il blocco di memoria compreso
			;							tra l'indirizzo ind1 (hex) e l'indirizzo ind2 (hex)
			;							a partire dall'indirizzo ind3 (hex)
			;
SYSMOVE		CALL SYSGETIID		; Chiama la 0x36C8 (L36C8 SYSGETIID)
L35C3		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			LD (BC),A			; Salva A in memoria puntata da (BC)
			CALL L36DD			; Chiama la 0x36DD (L36DD ?)
			JR L35C3			; Passa alla 0x35C3

			;
			; Routine 0x35CA - SYSSOST  Comando S di SYSTEM
			;							S ind
			;							Sostituisce il dato corrente contenuto
			;							nell'indirizzo ind (hex) 
			;							con il dato (hex) digitato in seguito
			;
SYSSOST		CALL L3671			; Chiama la 0x3671 (L3671 SYSGETI)
			POP HL				; Recupera HL dallo stack
L35CE		LD A,(HL)			; Carica in A da memoria puntata da (HL)
			CALL L3616			; Chiama la 0x3616 (L3616 VSHXB2)
			CALL WKSPCMCR		; Chiama la 0x3702 (L3702 WKSPCMCR)
			RET C				; Se CY=1, ritorna
			JR Z,L35E7			; Se zero, passa a 0x35E7
			CP 0x0A				; Compara A con il valore 0x0A (carattere LF)
			JR Z,L35E9			; Se uguale, passa a 0x35E9
			PUSH HL				; Salva HL nello stack
			CALL GETIND			; Chiama la 0x3668 (L3668 GETIND)
			POP DE				; Recupera DE dallo stack
			POP HL				; Recupera HL dallo stack
			LD (HL),E			; Salva E in memoria puntata da (HL)
			LD A,C				; Copia C in A
			CP 0x0D				; Compara A con il valore 0x0D (carattere CR)
			RET Z				; Se zero, ritorna
L35E7		INC HL				; Incrementa HL
			INC HL				; Incrementa HL
L35E9		DEC HL				; Decrementa HL
			LD A,L				; Copia L in A
			AND 0x07			; Esegue AND di A con il valore 0x07
			CALL Z,L361D		; Se zero, chiama la 0x361D (L361D VSWSHL)
			JR L35CE			; Passa a 0x35CE

			;
			; Routine 0x35F2 - HSUMDIF  Comando H di SYSTEM
			;							H dat1,dat2
			;							Visualizza 
			;							il risultato (hex) di dat1+dat2
			;							e
			;							il risultato (hex) di dat1-dat2
			;
HSUMDIF		CALL L3651			; Chiama la 0x3651 (L3651 GETV1V2)
			PUSH HL				; Salva HL nello stack
			ADD HL,DE			; Somma DE ad HL
			CALL L361D			; Chiama la 0x361D (L361D VSWSHL)
			POP HL				; Recupera HL dallo stack
			OR A				; Esegue OR di A
			SBC HL,DE			; Sottrae DE da HL
			JR VSWOHL			; Passa alla 0x3603 (L3603 VSWOHL)
		
			;
			; Routine 0x3600 - VSW2HL Stampa CR e word ASCII esadecimale corrispondente a binario in HL
			;   Input: HL word in binario
			;
L3600		CALL MONVCR			; Chiama la 0x3656 (L3656 MONVCR)
								;   continua con la 0x3603 (L3603 VSWOHL)

			;
			; Routine 0x3603 - VSWOHL Stampa word ASCII esadecimale corrispondente a binario in HL
			;   Input: HL word in binario
			;
VSWOHL		LD A,H				; Copia H in A
			CALL VSHXBY			; Chiama la 0x3608 (L3608 VSHXBY)
			LD A,L				; Copia L in A
								;   continua con la 0x3608 (L3608 VSHXBY)

			;
			; Routine 0x3608 - VSHXBY Stampa byte ASCII esadecimale corrispondente a binario in A
			;   Input: A valore binario
			;
VSHXBY		PUSH AF				; Salva AF nello stack
			RRCA				; Ruota a destra A di 1 bit
			RRCA				; Ruota a destra A di 1 bit
			RRCA				; Ruota a destra A di 1 bit
			RRCA				; Ruota a destra A di 1 bit
			CALL L3611			; Chiama la 0x3611 (L3611 VSHXCH)
			POP AF				; Recupera AF dallo stack
								;  continua con la 0x3611 (L3611 VSHXCH)

			;
			; Routine 0x3611 - VSHXCH Stampa carattere ASCII esadecimale corrispondente a binario in A
			;   Input: A valore binario
			;
L3611		CALL L36B0			; Chiama la 0x36B0 (L36B0 ATOCHX)
			JR VISHCPR			; Passa alla 0x3622 (L3622 VISHCPR)

			;
			; Routine 0x3616 - VSHXB2 Visualizza byte ASCII da valore binario in A, seguito da carattere -
			;  Input: A valore binario
			;
L3616		CALL VSHXBY			; Chiama la 0x3608 (L3608 VSHXBY)
L3619		LD C,0x2D			; Carica in C il valore 0x2D (carattere '-')
			JR VISHCPR			; Passa alla 0x3622 (L3622 VISHCPR)

			;
			; Routine 0x361D - VSWSHL Stampa CR, word ASCII esadecimale corrispondente a binario in HL e uno spazio
			;  Input: HL valore binario
			;
L361D		CALL L3600			; Chiama la 0x3600 (L3600 VSW2HL)
								;   continua con la 0x3620 (L3620 VISHCPRSP)
			
			;
			; Routine 0x3620 - VISHCPRSP Stampa spazio se HCOPY abilitato
			;
VISHCPRSP	LD C,' '			; Carica in C il valore 0x20 (carattere ' ')
								;   continua con la 0x3622 (L3622 VISHCPR)

			;
			; Routine 0x3622 - VISHCPR Visualizza carattere e lo stampa se HCOPY abilitato
			;   Input: C carattere da stampare
			;
VISHCPR		LD A,(PRNSTAT)		; Carica in A da memoria puntata da (0x4166) PRNSTAT
			BIT 0,A				; Test bit 0 di A
			JR Z,VISHCPREX		; Se zero, passa a 0x362C (L362C VISHCPR)
			CALL PRCHC			; Chiama la 0x3991 (L3991 PRCHC)
VISHCPREX	JP L3717			; Passa alla 0x3717 (L3717 STKHIOSCR)

			;
			; Routine 0x362F - WKALPHA	Attende un tasto e test se alfabetico
			;  Output: 
			;
WKALPHA		CALL L3711			; Chiama la 0x3711 (L3711 WKEYDE)
			CP '`'				; Compara A con il valore 0x60 (carattere '`')
			JP M,WKALPHAEX		; Se negativo, passa a 0x363E (L363E WKALPHAEX)
			CP '{'				; Compara A con il valore 0x7B (carattere '{')
			JP P,WKALPHAEX		; Se positivo passa a 0x363E (L363E WKALPHAEX)
			RES 5,A				; Reset del bit 4 di A 
WKALPHAEX	RET					; Ritorna

			; (Non utilizzato)
			;
			CALL MONVCR			; Chiama la 0x3656 (L3656 MONVCR)

			;
			; Routine 0x3642 - MONMSG Visualizza messaggio
			;   Input: HL puntatore a testo terminato con bit7=1
			;
L3642		PUSH BC				; Salva BC nello stack
L3643		LD C,(HL)			; Carica in C da memoria puntata da (HL)
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			RES 7,C				; Reset di C bit 7
			CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			INC HL				; Incrementa HL
			LD A,B				; Copia B in A
			RLCA				; Ruota A a sinistra di 1 bit (test fine messaggio)
			JR NC,L3643			; Se CY=0, passa a 0x3643
			POP BC				; Recupera BC dallo stack
			RET					; Ritorna

			;
			; Routine 0x3651 - GETV1V2  Ottiene due valori hex
			;   Output: DE primo valore, HL secondo valore
			;
L3651		CALL SYSGETID		; Chiama la 0x3673 (L3673 SYSGETID)
			POP DE				; Recupera DE dallo stack
			POP HL				; Recupera HL dallo stack
								;  continua con la 0x3656 (L3656 MONVCR)

			;
			; Routine 0x3656 - MONVCR  Visualizza CR
			;
MONVCR		PUSH HL				; Salva HL nello stack

			;
			; Routine 0x3657 - MONVCR2  Visualizza CR e recupera HL
			;
MONVCR2		LD HL,MCRCH			; Carica in HL il valore 0x375F (puntatore a CR)
			CALL L3642			; Chiama la 0x3642 (L3642 MONMSG)
			POP HL				; Recupera HL dallo stack
			RET					; Ritorna

			;
			; Routine 0x365F - KBST7  Restituisce stato tastiera in A
			;   Output: A stato bit7 stato tastiera
			;
KBST7		IN A,(PORT_KBDIN)	; Input in A da porta 0xEA (Interfaccia tastiera)
			BIT 7,A				; Test di A bit7
			LD A,0x00			; Azzera A
			RET Z				; Se zero, ritorna
			CPL					; Complementa A
			RET					; Ritorna

			;
			; Routine 0x3668 - GETIND  Ottiene un indirizzo
			;
GETIND		LD B,0x01			; Carica in B il valore 0x01
			LD HL,0x0000		; Azzera HL
			JR L3679			; Passa alla 0x3679 (L3679 ?)
										
										
			;
			; Routine 0x366F
			;											
L366F		JR NZ,MONPPT		; Se diverso da zero, passa a 0x3692 (L3692 MONPPT)
								;   altrimenti continua con la 0x3671 (L3671 SYSGETI)

			;
			; Routine 0x3671 - SYSGETI - Ottiene un indirizzo dalla linea di comando
			;   Output: BC dato (nello stack)
			;												
L3671		DEC B				; Decrementa B
			RET Z				; Se zero, ritorna
								;   altrimenti continua con la 0x3673 (L3673 SYSGETID)

			;
			; Routine 0x3673 - SYSGETID	 Ottiene un indirizzo e un dato dalla linea di comando
			;   Output: BC primo dato (nello stack), DE secondo dato (nello stack)
			;
SYSGETID	LD HL,0x0000		; Azzera HL
L3676		CALL WKAKPR			; Chiama la 0x36BD (L36BD WKAKPR)
								;   continua con la 0x3679 (L3679 ?)

			;
			; Routine 0x3679 
			;  Input: A ... HL ...
			;
L3679		LD C,A				; Copia A in C
			CALL HX2BIN			; Chiama la 0x36F2 (L36F2 HX2BIN)
			JR C,L3687			; Se CY=1, passa a 0x3687
			ADD HL,HL			; Raddoppia HL
			ADD HL,HL			; Raddoppia HL
			ADD HL,HL			; Raddoppia HL
			ADD HL,HL			; Raddoppia HL
			OR L				; Esegue OR di A con L
			LD L,A				; Copia A in L
			JR L3676			; Passa a 0x3676
L3687		EX (SP),HL			; Scambia HL con memoria puntata da (SP)
			PUSH HL				; Salva HL nello stack
			LD A,C				; Copia C in A
			CALL L3705			; Chiama la 0x3705 (L3705 ?)
			JR NC,L366F			; Se CY=0, passa alla 0x366F (L366F ?)
			DJNZ MONPPT			; Decrementa B, se diverso da zero passa a 0x3692 ??? (L3692 MONPPT)
			RET					; Ritorna

			;
			; Routine 0x3692 - MONPPT  Visualizza Propmt * e torna al menu
			;
MONPPT		LD HL,MASTK			; Carica in HL il valore 0x375E (Puntatore a '*' MASTK)
			CALL L3642			; Chiama la 0x3642 (L3642 MONMSG)
			JP SYSMNU			; Passa a 0x02DE (L02DE SYSMNU)

			; Non utilizzato
			;
			PUSH DE				; Salva DE nello stack
			LD E,A				; Copia A in E
			CALL L361D			; Chiama la 0x361D (L361D VSWSHL)
								;   continua con la 0x36A0 (L36A0 VISBIT)

			;
			; Routine 0x36A0 - VISBIT  Visualizza bit di E
			;   Input: E ?
			;
L36A0		LD B,0x08			; Carica in B il valore 0x08
L36A2		LD A,E				; Copia E in A
			RLCA				; Ruota A a sinistra di 1 bit
			LD E,A				; Copia A in E
			LD A,0x18			; Carica in A il valore 0x18
			RLA					; Ruota A a sinistra di 1 bit
			LD C,A				; Copia A in C
			CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			DJNZ L36A2			; Decrementa B, se diverso da zero passa a 0x36A2
			POP DE				; Recupera DE dallo stack
			RET					; Ritorna

			; 
			; Routine 0x36B0 - ATOCHX Converte valore binario in A nel corrispondente ASCII esadecimale
			;  Input: A valore binario
			;  Output: C ASCII esadecimale
			;
L36B0		AND 0x0F				; Esegue AND di A con il valore 0x0F
			ADD A,0x90			; Somma ad A il valore 0x90
			DAA					; Converte in BCD
			ADC A,0x40			; Somma ad A il valore 0x40
			DAA					; Converte in BCD
			LD C,A				; Copia A in C
			RET					; Ritorna

			; Non utilizzata
			;
L36BA		CALL L3619			; Chiama la 0x3619 (L3619 ?)
								;   continua con la 0x36BD (L36BD WKAKPR)

			;
			; Routine 0x36BD - WKAKPR Attende un tasto e lo stampa
			;  Output: A tasto premuto
			;
WKAKPR		CALL WKALPHA		; Chiama la 0x362F (L362F WKALPHA)
			PUSH BC				; Salva BC nello stack
			LD C,A				; Copia A in C
			CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			LD A,C				; Copia C in A
			POP BC				; Recupera BC dallo stack
			RET					; Ritorna

			;
			; Routine 0x36C8 - SYSGETIID - Ottiene tre valori (hex) dalla linea di comando
			;   Output: HL primo valore
			;			DE secondo valore
			;			BC terzo dato 
			;
SYSGETIID	INC B				; Incrementa B
			CALL SYSGETID		; Chiama la 0x3673 (L3673 SYSGETID)
			POP BC				; Recupera BC dallo stack
			POP DE				; Recupera E dallo stack
			JP MONVCR2			; Passa alla 0x3657 (L3657 MONVCR2)

			;
			; Routine 0x36D1 - INCHLCMPDE  Incrementa HL e lo confronta con DE
			;
INCHLCMPDE	INC HL				; Incrementa HL
			LD A,H				; Copia H in A
			OR L				; Esegue OR di A con L
			SCF					; CY=1
			RET Z				; Se zero, ritorna
			LD A,E				; Copia E in A
			SUB L				; Sottrae L da A
			LD A,D				; Copia D in A
			SBC A,H				; Sottrae H da A
			RET					; Ritorna

			;
			; Routine 0x36DB - DRPSTK  Elimina punto di rientro dallo stack e rientra al precedente
			;
DRPSTK		POP DE				; Recupera DE dallo stack
			RET					; Ritorna

			;
			; Routine 0x36DD
			;
L36DD		INC BC				; Incrementa BC
L36DE		CALL INCHLCMPDE		; Chiama la 0x36D1 (L36D1 INCHLCMPDE)
			JR C,DRPSTK			; Se CY=1, passa a 0x36DB (L36DB DRPSTK)
			CALL KBST7			; Chiama la 0x365F (L365F KBST7)
			OR A				; Esegue OR di A
			RET Z				; Se zero, ritorna
			CALL WKALPHA		; Chiama la 0x362F (L362F WKALPHA)
			CP CHCS				; Compara A con il valore 0x13 (tasto <CTRLS>)
			JR NZ,DRPSTK		; Se diverso da zero, passa a 0x36DB (L36DB DRPSTK)
			JP WKALPHA			; Passa alla 0x362F (L362F WKALPHA)

			;
			; Routine 0x36F2 - HX2BIN Converte A da carattere ASCII esadecimale a binario
			;   Input: A carattere ASCII esadecimale
			;
HX2BIN		SUB '0'				; Sottrae da A il valore 0x30 (carattere '0')
			RET C				; Se CY=1, ritorna
			CP 0x17				; Compara A con il valore 0x17
			CCF					; Inverte CY     
			RET C				; Se CY=1, ritorna
			CP 0x0A				; Compara A con il valore 0x0A
			CCF					; Inverte CY
			RET NC				; Se CY=0, ritorna
			SUB 0x07			; Sottrae da A il valore 0x07
			CP 0x0A				; Compara A con il valore 0x0A
			RET					; Ritorna

			;
			; Routine 0x3702 - WKSPCMCR Attende un tasto e lo visualizza, test se spazio, virgola o CR
			;   Output: Z=1			=> Spazio oppure ',' 
			;			Z=1 e C=1	=> <CR>
			;			Z=0 e C=0	=> Altro tasto
			;
WKSPCMCR	CALL WKAKPR			; Chiama la 0x36BD (L36BD WKAKPR)	
L3705		CP ' '				; Compara A con il valore 0x20 (carattere ' ')
			RET Z				; Se uguale, ritorna
			CP ','				; Compara A con il valore 0x2C (carattere ',')
			RET Z				; Se uguale, ritorna
			CP CHCR				; Compara A con il valore 0x0D (carattere <CR>)
			SCF					; CY=1
			RET Z				; Se uguale, ritorna
			CCF					; Inverte CY
			RET					; Ritorna

			;
			; Routine 0x3711 - WKEYDE Attende tasto e preserva DE
			;
L3711		PUSH DE				; Salva DE nello stack
			CALL WTKEYA			; Chiama la 0x0049 (L0049 WTKEYA)
			POP DE				; Recupera DE dallo stack
			RET					; Ritorna

			;
			; Routine 0x3717 - STKHIOSCR  Visualizza carattere, salva tutti i registri
			;   Input: C carattere da visualizzare
			;
L3717		PUSH AF				; Salva AF nello stack
			PUSH BC				; Salva BC nello stack
			PUSH DE				; Salva DE nello stack
			PUSH HL				; Salva HL nello stack
			LD A,C				; Copia C in A
			CALL HIOSCR			; Chiama la 0x0033 (L0033 HIOSCR)
			POP HL				; Recupera HL dallo stack
			POP DE				; Recupera DE dallo stack
			POP BC				; Recupera BC dallo stack
			POP AF				; Recupera AF dallo stack
			RET					; Ritorna

MNEMON		.TEXT ' N.E. MONITOR V. 1.', '0'+0x80

			; Tabella indirizzi per Monitor (TCMDMON)
			;
TCMDMON		.DW MONPPT			; 0x3692	(Menu Monitor)
			.DW MONRET			; 0x030B	Comando B
			.DW SYSCSCL			; 0x38D4	Comando CS e CL ?
			.DW SYSDAT			; 0x349F	Comando D
			.DW SYSTEM			; 0x02B2	(Torna a SYSTEM)
			.DW SYSFILL			; 0x031F	Comando F
			.DW SYSGO			; 0x34F1	Comando G
			.DW HSUMDIF			; 0x35F2	Comando H
			.DW SYSINP			; 0x35AF	Comando I
			.DW MONPPT			; 0x3692	(Menu Monitor)
			.DW MONPPT			; 0x3692	(Menu Monitor)
			.DW MONPPT			; 0x3692	(Menu Monitor)
			.DW SYSMOVE			; 0x35C0	Comando M
			.DW MONPPT			; 0x3692	(Menu Monitor)
			.DW SYSOUT			; 0x35B8	Comando O
			.DW SYSPRNON		; 0x0316	Comando P
			.DW SYSPRNOFF		; 0x031A	Comando Q
			.DW SYSREG			; 0x3760	Comando R
			.DW SYSSOST			; 0x35CA	Comando S

			; Messaggi da visualizzare
			;
MASTK		.TEXT 0x80+'*'		; *
MCRCH		.TEXT 0x80+0x0D		; CR

			;
			; Routine 0x3760 - SYSREG	Comando R e Rx di SYSTEM 
			;							R
			;							Visualizza i registri (hex) nell'ordine
			;							Flag/A, B/C, D/E, H/L, Stack Pointer, Program Counter
			;							RA
			;							Modifica il registro A/F
			;							RB
			;							Modifica il registro B/C
			;							RD
			;							Modifica il registro D/E
			;							RH
			;							Modifica il registro H/L
			;							RS			;							RA
			;							Modifica il registro Stack Pointer
			;							RP
			;							Modifica il registro Program Counter
			;
SYSREG		CALL WKSPCMCR		; Chiama la 0x3702 (L3702 WKSPCMCR)
			JP C,VISREGS		; Se CY=1, passa a 0x383C (L383C VISREGS)
								;   altrimenti continua con 0x3766

			;
			; Routine 0x3766
			;
L3766		JP Z,MONPPT			; Se zero, passa a 0x3692 (L3692 MONPPT)
			LD HL,TABREGL1		; Carica in HL il valore 0x3972 (L3972 TABREGL1)
			CP '''				; Compara A con il valore 0x27 (carattere ''')
			JR NZ,L3776			; Se diverso passa a 0x3776
			CALL WKAKPR			; Chiama la 0x36BD (L36BD WKAKPR)
			LD HL,TABREGL2		; Carica in HL il valore 0x3981 (L3981 TABREGL2)
L3776		CP 'F'				; Compara A con il valore 0x46 (carattere 'F') (comando Fill)
			JR Z,L37E3			; Se uguale, passa a 0x37E3 (L37E3 SYSFILL)
			CP 'A'				; Compara A con il valore 0x41 (carattere 'A') (comando A)
			JR Z,L37B5			; Se uguale, passa a 0x37B5 (L37B5 SYSCA)
L377E		LD B,(HL)			; Carica in B da memoria puntata da (HL)
			CP B				; Compara A con B
			JR Z,L3789			; Se uguale, passa a 0x3789 (L3789 ?)
			INC B				; Incrementa B
			JR Z,L3766			; Se zero, passa a 0x3766 (L3766 ?)
			INC HL				; Incrementa HL
			INC HL				; Incrementa HL
			JR L377E			; Passa a 0x377E
L3789		INC HL				; Incrementa HL
			LD E,(HL)			; Carica in E memoria puntata da (HL)
			LD D,0x00			; Azzera D
			LD HL,SPINI			; Carica in HL il valore 0x4167 (SPINI)
			ADD HL,DE			; Somma DE ad HL
			PUSH HL				; Salva HL nello stack
			PUSH AF				; Salva AF nello stack
			CALL MONVCR			; Chiama la 0x3656 (L3656 MONVCR)
			POP AF				; Recupera AF dallo stack
			LD C,A				; Copia A in C
			CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			CALL VISHCPRSP		; Chiama la 0x3620 (L3620 VISHCPRSP)
			POP HL				; Recupera HL dallo stack
			LD E,(HL)			; Carica in E memoria puntata da (HL)
			INC HL				; Incrementa HL
			LD D,(HL)			; Carica in D memoria puntata da (HL)
			EX DE,HL			; Scambia DE ed HL
			PUSH DE				; Salva DE nello stack
			CALL VSWOHL			; Chiama la 0x3603 (L3603 VSWOHL)
			CALL VISHCPRSP		; Chiama la 0x3620 (L3620 VISHCPRSP)
			LD B,0x01			; Carica in B il valore 0x01
			CALL SYSGETID		; Chiama la 0x3673 (L3673 SYSGETID)
			POP DE				; Recupera DE dallo stack
			POP HL				; Recupera HL dallo stack
			LD (HL),D			; Salva D in memoria puntata da (HL)
			DEC HL				; Decrementa HL
			LD (HL),E			; Salva E in memoria puntata da (HL)
			RET					; Ritorna

			;
			; Routine 0x37B5 - SYSCA	Comando A del Monitor
			;
L37B5		PUSH HL				; Salva HL nello stack
			CALL MONVCR			; Chiama la 0x3656 (L3656 MONVCR)
			POP HL				; Recupera HL dallo stack
			LD DE,TABREGL1		; Carica in DE il valore 0x3972 (L3972 TABREGL1)
			XOR A				; Azzera A
			SBC HL,DE			; Sottrae DE da HL
			LD HL,0x4168		; Carica in HL il valore 0x4168
			JR Z,L37C8			; Se zero, passa a 0x37C8
			LD HL,0x4174		; Carica in HL il valore 0x4174
L37C8		PUSH HL				; Salva HL nello stack
			LD C,0x41			; Carica in C il valore 0x41 (carattere 'A')
			CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			CALL VISHCPRSP		; Chiama la 0x3620 (L3620 VISHCPRSP)
			POP HL				; Recupera HL dallo stack
			LD A,(HL)			; Carica in A da memoria puntata da (HL)
			PUSH HL				; Salva HL nello stack
			CALL VSHXBY			; Chiama la 0x3608 (L3608 VSHXBY)
			CALL VISHCPRSP		; Chiama la 0x3620 (L3620 VISHCPRSP)
			LD B,0x01			; Carica in B il valore 0x01
			CALL SYSGETID		; Chiama la 0x3673 (L3673 SYSGETID)
			POP DE				; Recupera DE dallo stack
			POP HL				; Recupera HL dallo stack
			LD (HL),E			; Salva E in memoria puntata da (HL)
			RET     			; Ritorna

			;
			; Routine 0x37E3 - CFILL	
			;
L37E3		LD DE,TABREGL1		; Carica in DE il valore 0x3972 (L3972 TABREGL1)
			XOR A				; Azzera A
			SBC HL,DE			; Sottrae DE da HL
			LD HL,SPINI			; Carica in HL il valore 0x4167 (SPINI)
			JR Z,L37F1			; Se zero, passa a 0x37F1
			LD HL,0x4173		; Carica in HL il valore 0x4173
L37F1		PUSH HL				; Salva HL nello stack
			CALL WKAKPR			; Chiama la 0x36BD (L36BD WKAKPR)
			LD HL,0x3962		; Carica in HL il valore 0x3962
L37F8		LD B,(HL)			; Carica in B da memoria puntata da (HL)
			CP B				; Compara A con B
			JR Z,L3804			; Se uguale, passa a 0x3804
			INC B				; Incrementa B (Fine tabella?)
			JP Z,MONPPT			; Se zero, passa a 0x3692 (L3692 MONPPT)
			INC HL				; Incrementa HL
			INC HL				; Incrementa HL
			JR L37F8			; Passa a 0x37F8
L3804		INC HL				; Incrementa HL
			LD B,(HL)			; Carica in B da memoria puntata da (HL)
			LD D,B				; Copia B in D
			POP HL				; Recupera HL dallo stack
			PUSH HL				; Salva HL nello stack
			LD E,(HL)			; Carica in E da memoria puntata da (HL)
L380A		RL E				; Ruota a sinistra E di 1 bit
			DJNZ L380A			; Decrementa B, se diverso da zero passa a 0x380A
			PUSH DE				; Salva DE nello stack
			PUSH AF				; Salva AF nello stack
			CALL MONVCR			; Chiama la 0x3656 (L3656 MONVCR)
			POP AF				; Recupera AF dallo stack
			PUSH AF				; Salva AF nello stack
			LD C,A				; Copia A in C
			CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			CALL VISHCPRSP		; Chiama la 0x3620 (L3620 VISHCPRSP)
			POP AF				; Recupera AF dallo stack
			LD A,0x18			; Carica in A il valore 0x18
			RLA					; Ruota A a sinistra di 1 bit
			LD C,A				; Copia A in C
			CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			CALL VISHCPRSP		; Chiama la 0x3620 (L3620 VISHCPRSP)
			CALL WKAKPR			; Chiama la 0x36BD (L36BD WKAKPR)
			SUB 0x30			; Sottrae da A il valore 0x30 (carattere '0')
			SCF					; CY=1
			CCF					; Inverte CY
			RR A				; Ruota a destra A di 1 bit
			JP NZ,MONPPT		; Se diverso da zero, passa a 0x3692 (L3692 MONPPT)
			POP DE				; Recupera DE dallo stack
			LD B,D				; Copia D in B
L3835		RR E					; Ruota a destra E di 1 bit
			DJNZ L3835			; Decrementa B, se diverso da zero passa a 0x3835
			POP HL				; Recupera HL dallo stack
			LD (HL),E			; Copia E in memoria puntata da (HL)
			RET					; Ritorna

			;
			; Routine 0x383C - VISREGS visualizza registri
			;
VISREGS		LD BC,0x0502		; Carica in BC il valore 0x0502
			PUSH BC				; Salva BC nello stack
			LD HL,TABREGS		; Carica in HL il valore 0x3958 (puntatore a tabella registri TABREGS)
			PUSH HL				; Salva HL nello stack
			LD IX,SPINI			; Carica in IX il valore 0x4167 (SPINI)
			;
L3848		LD E,(IX+0x00)		; Carica in E da memoria puntata da (IX)
			INC IX				; Incrementa IX
			PUSH IX				; Salva IX nello stack
			CALL VISFLAGS		; Chiama la 0x389a (L389A VISFLAGS)
			;
			LD C,'A'			; Carica in C il valore 0x41 (carattere 'A')
			CALL HCPRSPCEQ		; Chiama la 0x38C5 (L38C5 HCPRSPCEQ)
			POP IX				; Recupera IX dallo stack
			LD A,(IX+0x00)		; Carica in A da memoria puntata da (IX)
			INC IX				; Incrementa IX
			PUSH IX				; Salva IX nello stack
			CALL VSHXBY			; Chiama la 0x3608 (L3608 VSHXBY)
			POP IX				; Recupera IX dallo stack
			POP HL				; Recupera HL dallo stack
			;
L3866		LD C,(HL)			; Carica in C da memoria puntata da (HL)
			INC HL				; Incrementa HL
			PUSH HL				; Salva HL nello stack
			PUSH IX				; Salva IX nello stack
			CALL HCPRSPCEQ		; Chiama la 0x38C5 (L38C5 HCPRSPCEQ)
			POP IX				; Recupera IX dallo stack
			LD L,(IX+0x00)		; Carica in L da memoria puntata da (IX)
			INC IX				; Incrementa IX
			LD H,(IX+0x00)		; Carica in H da memoria puntata da (IX)
			INC IX				; Incrementa IX
			PUSH IX				; Salva IX nello stack
			CALL VSWOHL			; Chiama la 0x3603 (L3603 VSWOHL)
			;
			POP IX				; Recupera IX dallo stack
			POP HL				; Recupera HL dallo stack
			POP BC				; Recupera BC dallo stack
			DEC B				; Decrementa B
			JR Z,L3889			; Se zero, passa alla 0x3880 (L3889 ?)
			PUSH BC				; Salva BC nello stack
			JR L3866			; Passa a 0x3866

			;
			; Routine 0x3889
			;  Input: C
			;
L3889		DEC C				; Decrementa C
			JP Z,SYSMNU			; Se zero, passa a 0x02DE (L02DE SYSMNU)
			LD B,0x05			; Carica in B il valore 0x05
			PUSH BC				; Salva BC nello stack
			PUSH HL				; Salva HL nello stack
			PUSH IX				; Salva IX nello stack
			CALL MONVCR			; Chiama la 0x3656 (L3656 MONVCR)
			POP IX				; Recupera IX dallo stack
			JR L3848			; Passa a 0x3848 (L3848 ?)

			;
			; Routine 0x389A - VISFLAGS  visualizza stato di tutti i flags 
			;  Input: E  flags da visualizzare
			;
VISFLAGS	LD HL,0x0000		; Azzera HL
			LD B,0x03			; Carica in B il valore 0x03
L389F 		SRL E				; Shift a destra di 1 bit di E
			CALL VISFLAG		; Chiama la 0x38B4 (L38B4 VISFLAG)
			SRL E				; Shift a destra di 1 bit di E
			INC HL				; Incrementa HL
			DJNZ L389F			; Decrementa B, se B non zero passa a 0x389F
			LD B,0x02			; Carica in B il valore 0x02
L38AB 		SRL E				; Shift a destra di 1 bit di E
			CALL VISFLAG		; Chiama la 0x38B4 (L38B4 VISFLAG)
			INC HL				; Incrementa HL
			DJNZ L38AB			; Decrementa B, se B non zero passa a 0x38AB
			RET     			; Ritorna

			;
			; Routine 0x38B4 - VISFLAG  visualizza stato di un flag
			;	Input: CY  flag da visualizzare
			;
VISFLAG		PUSH BC				; Salva BC nello stack
			PUSH HL				; Salva HL nello stack
			LD C,'-'			; Carica in C il valore 0x2D (carattere '-')
			JR NC,L38BF			; Se CY=0, passa a 0x38BF (se flag a zero, visualizza '-')
			LD BC,TABFLGS		; Carica in BC il valore 0x396D (Puntatore a tabella flags TABFLGS)
			ADD HL,BC			; Somma BC ad HL
			LD C,(HL)			; Carica in C da memoria puntata da (HL)
L38BF		CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			POP HL				; Recupera HL dallo stack
			POP BC				; Recupera BC dallo stack
			RET					; Ritorna     

			;
			; Routine 0x38C5 - HCPRSPCEQ  Visualizza e stampa (se HCOPY abilitato) 
			;					uno spazio, seguito dal carattere in C e un =
			;  Input: C carattere da visualizzare/stampare
			;
HCPRSPCEQ	PUSH BC				; Salva BC nello stack
			LD C,' '			; Carica in C il valore 0x20 (carattere ' ')
			CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			POP BC				; Recupera BC dallo stack
			CALL VISHCPR		; Chiama la 0x3622 (L3622 VISHCPR)
			LD C,'='			; Carica in C il valore 0x3D (carattere '=')
			JP VISHCPR			; Passa alla 0x3622 (L3622 VISHCPR)

			;
			; Routine 0x38D4 - SYSCSCL  Comandi CS e CL di SYSTEM
			;							CS ind1,ind2
			;								Registra su tape l'area di memoria compresa
			;								tra l'indirizzo ind1 (hex) e l'indirizzo ind2 (hex)
			;							CL 
			;								Legge da tape il programma e lo salva nell'area di memoria
			;								occupata in precedenza (indirizzo di partenza registrato sul tape)
			;							CL offset
			;								Legge da tape il programma e lo salva nell'area di memoria
			;								dall'indirizzo di partenza registrato sul tape sommato al valore offset
			;
SYSCSCL		LD A,0x10			; Carica in A il valore 0x10 (Out: Video)
			LD (CHNNO),A		; Salva A in memoria puntata da (0x403D) CHNNO
			CALL WKAKPR			; Chiama la 0x36BD (L36BD WKAKPR), attende tasto
			CP 'L'				; Compara A con il valore 0x4C (carattere 'L'), comando (L)OAD
			JR Z,CMDCL			; Se uguale, passa a 0x390F (L390F CMDCL)
			CP 'S'				; Compara A con il valore 0x53 (carattere 'S'), comando (S)AVE
			JP NZ,MONPPT		; Se diverso, passa a 0x3692 (L3692 MONPPT), con altro tasto termina
								;   altrimenti passa a 0x3805 (L3805 CMDCS)
			;
			; CS - Save (tape)  - 0x14 (Start L H) (End E D) ... mem byte ... 0x18
			;
CMDCS		LD B,0x02			; Carica in B il valore 0x02 (due valori in input)
			CALL SYSGETID		; Chiama la 0x3673 (L3673 SYSGETID) (legge i due indirizzi)
			POP DE				; Recupera DE dallo stack	(indirizzo finale)
			POP HL				; Recupera HL dallo stack	(indirizzo iniziale)
			RST VCPDEHL			; Chiama la RST 0x18 (L0018 VCPDEHL)
			JP NC,MONPPT		; Se CY=0, passa a 0x3692 (L3692 MONPPT) (se valori incoerenti, termina)
			CALL TP14DEL		; Chiama la 0x3943 (L3943 TP14DEL)
								; Scrittura indirizzo iniziale sorgente HL nel tape 
			LD A,L				; Copia L in A
			CALL VWRTAPE		; Chiama la 0x0264 (L0264 VWRTAPE)
			LD A,H				; Copia H in A
			CALL VWRTAPE		; Chiama la 0x0264 (L0264 VWRTAPE)
								; Scrittura indirizzo finale sorgente DE nel tape 
			LD A,E				; Copia E in A
			CALL VWRTAPE		; Chiama la 0x0264 (L0264 VWRTAPE)
			LD A,D				; Copia D in A
			CALL VWRTAPE		; Chiama la 0x0264 (L0264 VWRTAPE) 
								; Inizio loop lettura da memoria e scrittura in tape
WRTPLOOP	LD A,(HL)			; Carica in A da memoria puntata da (HL)
			CALL VWRTAPE		; Chiama la 0x0264 (L0264 VWRTAPE)
			RST VCPDEHL			; Chiama la RST 0x18 (L0018 VCPDEHL)
			INC HL				; Incrementa HL
			JR NZ,WRTPLOOP		; Se diverso da zero, passa a 0x3903 (L3903 WRTPLOOP)
			CALL DELS18			; Chiama la 0x01F5 (L01F5 DELS18)
			RET					; Ritorna
			;
			; CL - Load
			;
CMDCL		CALL WKSPCMCR		; Chiama la 0x3702 (L3702 WKSPCMCR)
			LD BC,0x0000		; Azzera BC (offset per default a 0)
			PUSH BC				; Salva BC nello stack
			JR C,L391F			; Se CY=1, passa a 0x391F (comando CL senza parametri, offset 0x0000)
			JP Z,MONPPT			; Se zero, passa a 0x3692 (L3692 MONPPT) (spazio, termina)
			POP BC				; Recupera BC dallo stack
			CALL GETIND			; Chiama la 0x3668 (L3668 GETIND) (inserisce offset nello stack)
L391F		CALL TP10DEL10		; Chiama la 0x394E (L394E TP10DEL10)
								; Lettura indirizzo iniziale di destinazione da tape in HL
			CALL VRDTAPE		; Chiama la 0x0235 (L0235 VRDTAPE)
			LD L,A				; Copia A in L
			CALL VRDTAPE		; Chiama la 0x0235 (L0235 VRDTAPE)
			LD H,A				; Copia A in H
								; Lettura indirizzo finale di destinazione da tape in DE
			CALL VRDTAPE		; Chiama la 0x0235 (L0235 VRDTAPE)
			LD E,A				; Copia A in E
			CALL VRDTAPE		; Chiama la 0x0235 (L0235 VRDTAPE)
			LD D,A				; Copia A in D
								; Somma a indirizzo iniziale e finale l'offset in BC
			POP BC				; Recupera BC dallo stack
			EX DE,HL			; Scambia DE ed HL
			ADD HL,BC			; Somma BC ad HL
			EX DE,HL			; Scambia DE ed HL
			ADD HL,BC			; Somma BC ad HL
								; Inizio loop lettura da tape e scrittura in memoria
RDTPLOOP	CALL VRDTAPE		; Chiama la 0x0235 (L0235 VRDTAPE)
			LD (HL),A			; Salva A in memoria puntata da (HL)
			RST VCPDEHL			; Chiama la RST 0x18 (L0018 VCPDEHL)
			INC HL				; Incrementa HL
			JR NZ,RDTPLOOP		; Se diverso, passa a 0x3937 (L3937 RDTPLOOP)
			CALL DELS18			; Chiama la 0x01F5 (L01F5 DELS18)
			RET					; Ritorna   

			;
			; Routine 0x3943 - TP14DEL  Invia al registratore il byte 0x14 e ritarda, accende motore 1
			;
TP14DEL		LD A,0x14			; Carica in A il valore 0x14
			OUT (PORT_TAPED),A	; Out di A su porta 0xEF (Interfaccia cassette)
			CALL DELAY			; Chiama la 0x31F4 (L31F4 DELAY)
			CALL DELAY			; Chiama la 0x31F4 (L31F4 DELAY)
			RET     			; Ritorna

			;
			; Routine 0x394E - TP10DEL10  Invia al registratore il byte 0x10, 
			;							  ritarda e di nuovo invia il byte 0x10, avvia motore 1
			;
TP10DEL10	LD A,0x10			; Carica in A il valore 0x10
			OUT (PORT_TAPED),A	; Out di A su porta 0xEF (Interfaccia cassette)
			CALL DELAY			; Chiama la 0x31F4 (L31F4 DELAY)
			OUT (PORT_TAPED),A	; Out di A su porta 0xEF (Interfaccia cassette)
			RET					; Ritorna    

			; Tabella registri
			;
TABREGS		.TEXT 'BDHSPBDHXY'

			; Tabella Flags
			;
			.BYTE 'C', 0x08
			.BYTE 'E', 0x06
			.BYTE 'I', 0x04
			.BYTE 'Z', 0x02
			.BYTE 'M', 0x01
			.BYTE 0xFF			; Fine tabella

			; Tabella flags
			;
TABFLGS		.TEXT 'CEIZM'

			; Tabella registri
			;
TABREGL1	.BYTE 'B', 0x02     
			.BYTE 'D', 0x04     
			.BYTE 'H', 0x06     
			.BYTE 'S', 0x08     
			.BYTE 'P', 0x0a     
			.BYTE 'X', 0x14     
			.BYTE 'Y', 0x16     
			.BYTE 0xFF			 ; Fine tabella

			; Tabella registri
			;
TABREGL2	.BYTE 'B', 0x0E
			.BYTE 'D', 0x10
			.BYTE 'H', 0x12
			.BYTE 0xFF			; Fine tabella

			;
			; Routine 0x3988 - CMON
			;
CMON		XOR A				; Azzera A (attiva motore registratore)
			OUT (PORT_TAPED),A	; Out di A su porta 0xEF (Interfaccia cassette)
			CALL WTKEYA			; Chiama la 0x0049 (L0049 WTKEYA)
			JP BASMAIN			; Passa a 0x1A19 (L1A19 BASMAIN)


			; 
			; Routine 0x3991 - PRCHC  Stampa un carattere su stampante
			;   Input: C carattere da stampare (preservato)
			;
PRCHC		PUSH BC				; Salva BC nello stack
			CALL PRCHAR			; Chiama la 0x049F (L049F PRCHAR)
			POP BC				; Recupera BC dallo stack
			RET 				; Ritorna		    

			; 0xFF da 0x3997 A 0x3FFF  (A DISPOSIZIONE)
			;
			DEFS 0x0668, 0xFF
ENDROM		.BYTE 0xFF			; *** END ROM ***